Mechatronics xxx (2015) xxxxxx

Contents lists available at ScienceDirect

Mechatronics
journal homepage: www.elsevier.com/locate/mechatronics

Self-reconguration of real-time communication in cyber-physical

systems
Jan Jatzkowski , Bernd Kleinjohann
Cooperative Computing & Communication Laboratory (C-LAB), University of Paderborn, Fuerstenallee 11, 33102 Paderborn, Germany

a r t i c l e

i n f o

Article history:
Received 16 October 2014
Revised 10 February 2015
Accepted 19 April 2015
Available online xxxx
Keywords:
Cyber physical systems
Distributed embedded systems
Dynamic reconguration
Plug-and-Produce
Real-time communication
Real-time systems

a b s t r a c t
Today, in domains like automation and robotics systems consist of various sensors and computation
nodes. Due to the temporal dependency in quality of measured data, such Cyber-Physical Systems
(CPS) commonly have real-time requirements on communication. In addition, these systems shall
become more exible and scalable, e.g., by adding new components to the CPS. This would be most suitable if a CPS could react to the presence of a new component and recongure itself to run afterward with
the new component integrated to the CPS. This capability is covered by the term Plug-and-Produce. In
this paper, we propose a concept to enable Plug-and-Produce within a CPS whose network uses different
communication media, e.g., Ethernet and CAN. To enable real-time communication provided by different
communication protocols, their different synchronization mechanisms have to be combined to get a common time base within the entire system. For this purpose, we consider Ethernet as well as CAN-based
real-time communication protocols and their synchronization mechanisms. The proposed concept for
self-reconguration aims to be integrated into our three layered software architecture that is presented
as well.
2015 Elsevier Ltd. All rights reserved.

1. Introduction
Nowadays, interaction between a variety of system components
controlling physical entities becomes more and more important. In
[1], Lee and Seshia dene that Cyber-Physical Systems (CPS) are
about the intersection of these physical and cyber entities.
Depending on the application domain, these systems require at
least partial real-time communication and in case of dynamically
adaptable systems, this even implies reliable reconguration of
the communication, especially real-time communication.
Although such reconguration is already manually practicable, this
process is error-prone and strongly time consuming due to user
interaction. To overcome these issues, self-reconguration of such
systems is required. In automation domain, e.g., self-reconguration after modication of a production line promises not only to
be less error-prone and time-consuming, but also enables a higher
utilization of available system components and cost reduction. To
enable self-reconguration of real-time communication within
CPS, we present a three layered software architecture based on
the ISO/OSI reference model: Each node of the networked system
Corresponding author.
E-mail addresses: jan.jatzkowski@c-lab.de (J. Jatzkowski), bernd.kleinjohann@
c-lab.de (B. Kleinjohann).

has an application, middleware, and connectivity layer. While elements of the application layer represent particular functionality of
a system components application domain, the connectivity layer
provides the interfaces to the communication channels provided
by the hardware of a system component. The middleware layer
connects the application and connectivity layer and is responsible
for managing inter-node communication, i.e. communication
between applications mapped on different nodes of a networked
system. A rst description of the corresponding concepts is given
in [2]. To enable real-time capabilities within a system utilizing
different communication protocols without violating these protocols specications, we have to combine their communication
mechanisms to establish a common time base. Therefore, the presented middleware does also cover time synchronization in such a
Heterogeneous system. Due to this, we further provide an overview of particular synchronization mechanisms used by considered communication protocols.
In this paper, we focus on the middleware layer of our architecture, especially on real-time communication and its automatic
reconguration. Real-time communication is usually realized by a
time-triggered approach, i.e. time slots are assigned to nodes that
are only allowed to send information within these assigned slots.
The proposed self-reconguration concept considers modications like integration of new components to the overall system,

http://dx.doi.org/10.1016/j.mechatronics.2015.04.014
0957-4158/ 2015 Elsevier Ltd. All rights reserved.

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014

J. Jatzkowski, B. Kleinjohann / Mechatronics xxx (2015) xxxxxx

i.e. Plug-and-Produce capabilities. Safe modications are realized

by means of pre-dened time slots that are reserved, e.g., for
introduction of new system components into the CPS. When such
a modication is registered by the CPS, a self-reconguration process is started within the middleware layer. During this reconguration, our approach considers the required communication
from application layer and creates a new assignment of time slots
to system components guaranteeing required real-time capabilities. While the self-reconguration process itself does not need
to provide real-time capabilities, its result has to guarantee the
real-time requirements of the new system conguration.
Thus, the main contribution of this paper is the description of
our concept for reconguration of real-time communication within
a CPS by utilizing a common time-triggered communication mechanism that abstracts from real-time protocol specic characteristics. This way, our middleware will enable handling real-time
communication requests from application software resided in
application layer without knowledge of the real-time communication protocols provided by the connectivity layer that manages
hardware interfaces. In addition, to enable Plug-and-Produce capabilities our concept is designed to have particular slots reserved for
registering new components added to a CPS.
The remainder of this paper is structured as follows. In
Section 2, fundamentals about Plug-and-Produce as well as realtime communication are presented that are used to compare the
presented concept with related work. Then, related work is
described in Section 3. Our concept for self-reconguration is presented in Section 4. Here, we will discuss time synchronization of
particular communication protocols as well. This way, we can
identify capabilities to synchronize different protocols and establish a common time base. Finally, the paper is closed by a conclusion and outlook in Section 5.
2. Fundamentals
This section provides fundamentals about concepts of Plugand-Produce and real-time communication. This will support
the analysis of related work in Section 3 as well as classication of the proposed concept for self-reconguration presented
in Section 4.
2.1. Plug-and-Produce
Plug-and-Produce is known from domains like automation and
robotics. It is based on the Plug-and-Play technology that originally
was developed for general purpose computers as used in ofce
applications and is known, e.g., from the commonly used
Universal Serial Bus (USB). Due to the domain-specic requirements of automation and robotics, the term Plug-and-Produce
was introduced by the EU funded project SMErobot [3]. In [4],
Naumann et al. focus on robot cells at shop oors and dene
Plug-and-Produce as the ability to add devices to a robot cell and
to use the functionality of these devices without the need of conguration. Based on this denition, they dene three Plug-andProduce layers:
Application Offers automatically services to the user depending
on the available functionality.
Conguration Congures default values, bandwidth requirements, etc.
Communication Deals with communication protocols and provides, e.g., discovery and addressing of devices.
These layers are hierarchically ordered: Plug-and-Produce on
Application layer requires Plug-and-Produce on Conguration

layer; Plug-and-Produce on Conguration layer requires Plugand-Produce on Communication layer.

To compare our concept with state-of-the-art approaches and
highlight differences more precisely, we use an additional way to
classify Plug-and-Produce respectively Plug-and-Play implementations. This classication depends on the system performance and is
given by Zimmermann et al. [5]:
Cold The entire system is shot down, new components are connected and nally, the system is switched on again.
Recongurations needed due to the modications of the system
are processed during start-up phase.
Hot Components are added to or removed from the system during runtime. However, running applications must not be disturbed by this process.
Coordinated Adding and removing of components is user or
program controlled. This way, modication of a system is no
longer enabled at an arbitrary point in time, but rather
announced to the system. Thus, running applications cannot
be disturbed by a randomly occurring reconguration process.
These two complementary ways to classify Plug-and-Produce
approaches will be considered for related work in Section 3.
2.2. Real-time communication
Due to the interaction between physical and computational
entities within a CPS, timing behavior of communication is important for correctness of results produced by a CPS. Not only the measurements of sensors and processing of theses measured data but
also the transmissions of these data have to be nished before a
pre-dened deadline to achieve correct behavior of a CPS.
Therefore, Kopetz states that real time is an integrated part of
the real world that cannot be abstracted away [6]. In [7],
Buttazzo distinguishes three levels of real-time depending on the
consequences of missing a deadline: hard, rm, and soft real-time.
In soft real-time systems, missing a deadline causes performance
degradation, but results can still be useful for the system. In contrast, results of a rm real-time system are useless when missing
a deadline and in hard real-time systems, missing a deadline
may even cause catastrophic consequences on the controlled system. Consequently, different real-time systems can differ with
respect to the consequences of missing a deadline although all of
them are labeled real-time.
With respect to real-time communication, Kopetz denes a set
of requirements including timeliness and exibility [8]. Timeliness
covers among others clock synchronization, i.e. a global time base
is required. This way, observations like sensor measurements are
guaranteed to be temporally relevant for the controlled system
when processed by a computation node. Flexibility refers to the
adaptation capabilities of real-time communication in case of different supported system congurations that can change over time.
It should be possible to add new sensors and/or computation nodes
to a CPS without violating temporal guarantees of the original CPS.
However, exibility is limited by the bandwidth available by the
given communication channels.
In the automation and robotic domain, communication is often
based on Ethernet as well as Controller Area Network (CAN) as protocols to realize physical and data link layer of the standardized
OSI 7-layer reference model. Ethernet and CAN both are capable
of event-triggered communication. Since events can occur at an
arbitrary point in time, i.e. randomly, no temporal guarantees can
be provided in general. For instance, two sensors want to transmit
their data at the same time via the same communication channel
to the same computation node. In case of Ethernet, this would
result in a collision that has to be handled by the protocol. In case

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014

J. Jatzkowski, B. Kleinjohann / Mechatronics xxx (2015) xxxxxx

of CAN, one of the sensor nodes messages would have a higher priority and thus postpone transmission of the other sensor data. This
example shows that neither Ethernet nor CAN provide real-time
capabilities in general.
However, there exist techniques to get real-time performance
based on these protocols, e.g. switch technology improved
Ethernet by eliminating collisions [9]. Examples of real-time
Ethernet protocols built on top of standard Ethernet are
PROFINET [10], EtherCAT [11], and Ethernet-Powerlink [12].
Based on CAN, e.g., the time-triggered CAN (TTCAN) protocol has
been evolved to achieve real-time capabilities [13].

Although approaches for network reconguration are usually

focused on handling changes in communication and hardware
setup, typical network-related aspects like network-induced issues
e.g., timing delays and signal dropouts inuence this topic as
well. In [16,17] Zhang et al. investigated networks in the context
of lter problems. They propose to cover network-induced issues
in a passive way, i.e. handling these by designing network-issuetolerant controllers and lters. This way, system costs are usually
not increased. Further work on the design of such tolerant controllers has been presented by Shuai et al. [18]. They considered
timing delays of CAN in the context of in-vehicle communication
between different controllers.

3. Related work
4. Concept for self-reconguration
Different approaches for (re-)conguration of networks exist in
literature, each focusing on different aspects of this problem. In [6],
Kopetz and Bauer present the time-triggered architecture for realtime communication strongly focusing on fault tolerance, e.g., by
means of different kinds of redundancy. Nevertheless, the authors
do not address Plug-and-Play functionality, but rather refer to the
fact that one of the considered protocols, namely TTP/A, provides
such capabilities.
Reinhart et al. [14] address automatic reconguration of industrial Ethernet networks and present a ve-step-model for a coordinated Plug-and-Produce within Ethernet-based networks. But in
contrast to our concept that covers, e.g., CAN in addition to
Ethernet communication, they only consider Ethernet as communication medium within a CPS.
In [15], Marau et al. present a middleware supporting reconguration of real-time networks. Their approach provides hard realtime guarantees and covers hot Plug-and-Play not only by means
of adding new components to the system, but also removing of
nodes. But in contrast to the concept presented in this paper they
focus on Ethernet as communication medium and dene their own
communication protocol called FTT-SE. Thus, they do not capture
standard communication protocols like Ethernet Powerlink that
are currently used in domains like automation and robotics.

The goal of our proposed concept is to enable self-reconguration of a CPS where reconguration is activated by a Plug-andProduce step. Here, a CPS may use different communication media
for sub-systems, e.g., Ethernet and CAN. Therefore, our approach is
also applicable to CPSs with gateways connecting different subsystems.
An example of such a CPS is shown in Fig. 1 where three robot
cells are connected to each other via Ethernet. Furthermore, a camera for production monitoring and a supervising control entity are
connected to this Ethernet network. Due to the production the rst
robot cell is additionally connected via CAN to sensors for measuring temperature and humidity. Moreover, the last robot cell is connected to an air pressure sensor via CAN. A user can interact with
the CPS over an additional connection to the supervising control
entity.
4.1. Software architecture supporting self-reconguration
To provide a common base for communication within a CPS, we
propose a three layered software architecture composed of an application layer, middleware, and connectivity layer. A schematic view
to this architecture is shown in Fig. 2. The goal of this architecture is

Fig. 1. Example of a cyber-physical system. Sensors for measurement of temperature, humidity, and air pressure are connected to different robot cells via CAN. Robot cells are
connected to each other as well as to a control node and a camera via Ethernet.

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014

J. Jatzkowski, B. Kleinjohann / Mechatronics xxx (2015) xxxxxx

In this paper we address self-reconguration of a CPS, e.g.,

required for Plug-and-Produce. Due to this, in the following we will
focus on the middleware of the presented software architecture
that manages communication within a CPS.
4.2. Abstraction of communication media within the middleware
Separating applications from communication media is realized
within the middleware of our software architecture by a uniform
abstraction of all available communication media. Since we want
to provide real-time capabilities, we dene an abstract cycle-based
time-triggered communication medium: Cycles with a xed duration (cycle length) are specied where each cycle consists of three
phases as depicted in Fig. 3:
Phase 0 is used for synchronization and thus processes preparations for Phase 1.
Phase 1 is split into slots of predened equal length to cover
real-time communication.
Phase 2 can be used for event-triggered data transmissions, i.e.
non-real-time communication.

Fig. 2. Three layered software architecture supporting self-reconguration.

to separate application functionalities from communication mechanisms in such a way that a functional unit only species its requirements for data transmission by means of Quality -of-Service (QoS)
attributes. Within the connectivity layer a set of communication
protocols is implemented, e.g. CAN and the Ethernet-based realtime capable protocol Ethernet Powerlink. These communication
protocols are also described by a set of attributes that provide information to the middleware about their specic QoS capabilities. This
way, the middleware can compare the required QoS attributes
requested by the application layer to the provided QoS capabilities
given by the available communication protocols within the connectivity layer. Based on this comparison, the middleware can determine all appropriate communication protocols that provide the
required QoS attributes and choose one of them, e.g., depending
on the current network load.
While hard real-time requirements of running applications
must be guaranteed, soft or non-real-time communication
requests of applications might be acceptable to miss. Therefore,
the middleware is enabled to give feedback to the application layer
if such communication requests of running applications cannot be
served, e.g., because limits of available bandwidth are reached. This
is also useful when adding a new component to a CPS because the
system must be enabled to cancel integration of a new component
if its additional communication would disturb the correct timing
and behavior of the original running CPS. In this case, the component that was aimed to be integrated into the CPS would not be
started. Moreover, the middleware signals the application layer
that integration of the new component failed.
Since applications only specify QoS attributes regarding data
transmissions required to proceed correctly, the middleware is
enabled to modify communication behavior as long as it keeps
QoS requirements fullled. In principle, this even allows to switch
communication of an application from one communication medium to another. Thus, load balancing for non-real-time communication can be realized, too.

Most real-time capable communication protocols are based on

time-triggered approaches, i.e. these protocols have a similar structure to the proposed abstract communication medium shown in
Fig. 3. Consequently, on the one hand, parameters of the common
abstract communication medium e.g. cycle length, length of the
different phases, and slot length within Phase 1 have to depend
on the real communication media within a CPS.
On the other hand, the global time base that is required for realtime communication within a CPS can be established based on the
synchronization mechanisms already implemented by the underlying communication protocols. This supports establishing a global
time base, but it will also cause additional jitter due to the need of
synchronizing time bases of different protocols that already
include jitter caused by the protocol specic synchronization. To
highlight these aspects, we exemplary describe time synchronization as specied by TTCAN and Ethernet Powerlink. Comparing
both synchronization mechanisms illustrates similarity of synchronization techniques utilized in the context of different established
real-time communication protocols and thus conrms our
approach of an abstract communication medium.
4.2.1. Time synchronization in TTCAN
In [19], Hartwich et al. describe two levels of TTCAN implementation that distinguish with respect to synchronization. Although
both implementation levels utilize a reference message sent by a
so-called time master within the TTCAN network, they vary
regarding the provided information for synchronization. TTCAN
implementation level 1 uses that point in time for synchronization
when the reference message has been received by a node, i.e. each
node resets its local time when a reference message has been
received.
In contrast, TTCAN implementation level 2 even provides a continuous value as global time for the entire TTCAN network. To

Fig. 3. Cycle of the abstract communication medium.

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014

J. Jatzkowski, B. Kleinjohann / Mechatronics xxx (2015) xxxxxx

enable such a global time value, the TTCAN time master includes
its own local time into the reference message. Thus, current global
time t global within a TTCAN network can be locally computed by
each node as

t global t local Dlocal

where t local is current local time of the considered node and Dlocal is
the difference between the global time received by the reference
message and the local time at that point in time when the reference message was received by the appropriate node.
4.2.2. Time synchronization in Ethernet Powerlink
According to the communication prole specication [20] provided by Ethernet Powerlink Standardization Group (EPSG), the
master node shall send a so-called start-of-cycle frame (SoC) to
all controlled nodes via broadcast. Similar to the reference message
described in Section 4.2.1, this SoC frame contains a specic message type identication that enables controlled nodes to identify
the beginning of a new cycle. Each node uses the point in time
when it has received the SoC frame as reference point.
In addition, SoC frame can also include the starting time of the
Powerlink cycle, i.e. the local time of the master node when it creates the SoC frame. This starting time can be used by the controlled
nodes to establish a global time.
4.3. Self-reconguration to enable Plug-and-Produce
As described in Section 2.1, different classes of Plug-andProduce are known from literature. Here, we address a coordinated
Plug-and-Produce, i.e. integration of a new component to the running CPS is processed at a point in time that is controlled by the
running CPS itself. This way, we avoid to disturb the running CPS
during its reconguration process.
The presence of a new component within a running CPS is
noticed as follows: One slot within Phase 1 of the abstract communication medium is reserved for registration of a new component
during runtime of the CPS. This way, we can guarantee that adding
a new component can be noticed by the CPS within each cycle of
the abstract communication medium. A newly added component
has to signal its presence depending on the transmission paradigm
of the underlying communication medium it has been added to.
Consider the case that a new computation entity for processing
sensor data needs to be integrated into the CAN network of the rst
robot cell shown in Fig. 1. Due to the publish-subscribe communication model used by CAN, a component newly connected to the
CAN bus is enabled to read all sent messages. Consequently, the
middleware of the added component is able to access synchronization messages transmitted during Phase 0 and synchronize itself
with the CAN-based sub-system. Based on the established global
time, the new component can send a self-description within the
slot of Phase 1 that is reserved for registration of new components.
The self-description of a component that is send at rst contains
information about the provided functionality as well as required
and provided data. Since data size of the self-description depends
on provided functionality and data dependencies of a component,
transmission of these data can require more than one slot. In such
a case, transmission of self-description data is continued at the
next cycle using the reserved slot for recognition of new
components.
Consider the case of adding a new computation entity to the
Ethernet-based network shown in Fig. 1, e.g., to add image processing capabilities to the camera-based production monitoring. Here,
we can procedure based on the ve-step model for Plug-andProduce introduced by Reinhart et al. [14]. After the new component has been physically connected to the Ethernet network, its

presence has to be noticed by the running CPS. In [14], Reinhart

et al. state that various methods are known to accomplish detecting new components within Ethernet-based networks, e.g., pings,
broadcasts or IP scanners. Due to the way we proposed to register
a new component within a CAN sub-system, we want that a CPS
recognizes the presence of a new component within the reserved
slot of Phase 1 also in case of an underlying Ethernet-based communication medium. Therefore, we propose to dene a reserved
address that must be initially used by a new component. This
way, the CPS can ping this address to check presence of a new component. This ping has to be processed at the start of the pre-dened
slot in Phase 1 that is reserved for registration within each cycle of
the abstract time-triggered communication medium. Since the
ping is processed at the beginning of the registration slot, the
new component is able to transmit its self-description data after
the ping has been received.
Now, that the CPS has recognized the presence of a new component independent of the underlying communication medium,
reconguration of the communication can start. To keep the current real-time guarantees valid, one approach to integrate the
newly added and recognized component into the running CPS is
utilizing unused slots within Phase 1 for real-time communication
required by the new component. But availability of any unused
slots within Phase 1 does not imply that real-time communication
requirements of the new component can be guaranteed. Therefore,
the middleware has to check if the required real-time communication can be processed by using the available slots. In this case, the
middleware will assign the corresponding slots for the new realtime data transmissions and initialize start-up phase of the newly
added applications. Otherwise, the middleware gives an appropriate feedback to the application layer that a newly added component could not be started because no suitable reconguration
was found. Those data transmissions that have no real-time
requirements will be processed within Phase 2 of the abstract
time-triggered communication medium. Since these data are not
time-critical, the CPS will process correctly with respect to both,
timing and behavior even if data transmissions are postponed to
later cycles.
During the process of checking real-time guarantees, the original CPS keeps running. Hence, the proposed concept provides a
coordinated Plug-and-Produce that does not disturb running applications of the original system.
5. Conclusion
We presented a concept for self-reconguration of real-time
communication within a CPS that can be composed of sub-systems
using different communication media, e.g., Ethernet and CAN. The
software architecture proposed in Section 4.1 supports coordinated
Plug-and-Produce functionality based on a common abstract cyclebased time-triggered communication medium which ensures that
adding a new component can be registered by the CPS within one
cycle. We described synchronization mechanisms specied by particular communication protocols. Furthermore, we presented how
registration of a new component can be processed during runtime
when added to an Ethernet sub-system as well as a CAN subsystem.
In our future work, we want to prove the applicability of our
concept for self-reconguration. For this purpose, we aim at building a demonstrator system using different time-triggered communication protocols, e.g. Ethernet Powerlink and TTCAN.
Consequently, the evaluation platform will have to contain several nodes to get at least two sub-networks: Nodes of one sub-network have to provide Ethernet-based network interfaces and
communicate via Ethernet Powerlink. An open-source software
stack implementation of Ethernet Powerlink protocol is

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014

J. Jatzkowski, B. Kleinjohann / Mechatronics xxx (2015) xxxxxx

openPowerlink [21] published under BSD license. Nodes of at least

one additional sub-network have to communicate via TTCAN and
therefore have to be equipped with CAN controllers.
A promising hardware platform to realize this setup is the single-chip computer RaspberryPi [22]. On the one hand, since revision B it provides Ethernet interface; on the other hand,
RaspberryPi is extendible by expansion boards and thus could also
be equipped by a CAN controller. This hardware setting will serve
as platform for an implementation and evaluation of the proposed
concept.
Acknowledgements
This work was partly funded by the German Ministry of
Education and Research (BMBF) through the project its OWL
Intelligente Technische Systeme OstWestfalenLippe (02PQ1021).

[6]
[7]
[8]
[9]

[10]
[11]
[12]
[13]

[14]

[15]

References
[1] Lee EA, Seshia SA. Introduction to embedded systems a cyber-physical
systems approach; 2011. <http://LeeSeshia.org>.
[2] Jatzkowski J, Kleinjohann B. Towards self-reconguration of real-time
communication
within
cyber-physical
systems.
Procedia
Technol
2014;15(0):5461 [2nd International Conference on System-Integrated
Intelligence: Challenges for Product and Production Engineering].
[3] The European robot initiative for strengthening the competitiveness of SMEs in
manufacturing; 2014. <http://www.smerobot.org>.
[4] Naumann M, Wegener K, Schraft RD. Control architecture for robot cells to
enable PlugnProduce. In: IEEE international conference on robotics and
automation; 2007. p. 28792.
[5] Zimmermann UE, Bischoff R, Grundwald G, Plank G, Reintsema D.
Communication, conguration, application the three layer concept for

[16]

[17]
[18]

[19]
[20]
[21]
[22]

plug-and-produce. In: Proceedings of the 5th international conference on

informatics in control, automation and robotics (ICINCO); 2008. p. 25562.
Kopetz H, Bauer G. The time-triggered architecture. In: Proceedings of the
IEEE; 2003. p. 11226.
Buttazzo GC. Hard real-time computing systems predictable scheduling
algorithms and applications. Springer; 2011.
Kopetz H. Real-time systems design principles of distributed embedded
applications. Springer; 2011.
Zhang L, Wang Z. Real-time performance evaluation in hybrid industrial
ethernet networks. In: Proceedings of the 8th world congress on intelligent
control and automation; 2010. p. 18425.
Pi probus & pronet international; 2014. <www.probus.com>.
Ethercat technology group home; 2014. <http://www.ethercat.org>.
EPSG homepage; 2013. <http://www.ethernet-powerlink.org>.
Fhrer T, Mller B, Dieterle W, Hartwich F, Hugel R, Walther M. Time triggered
communication on can (time triggered can-ttcan); 2014. <http://www.boschsemiconductors.de/media/pdf_1/canliteratur/cia2000paper_1.pdf>.
Reinhart G, Krug S, Httner S, Mari Z, Riedelbauch F, Schlgel M. Automatic
conguration (plug & produce) of industrial ethernet networks. In: 9th IEEE/
IAS international conference on industry applications (INDUSCON); 2010.
p. 16.
Marau R, Almeida L, Sousa M, Pedreiras P. A middleware to support dynamic
reconguration of real-time networks. In: IEEE conference on emerging
technologies and factory automation (ETFA); 2010. p. 110.
Zhang H, Shi Y, Wang J. On energy-to-peak ltering for nonuniformly sampled
nonlinear systems: a markovian jump system approach. IEEE Trans Fuzzy Syst
2014;22(1):21222.
Zhang H, Wang J. State estimation of discrete-time Takagi-Sugeno fuzzy
systems in a network environment. IEEE Trans Cybern 2014;PP(99):1.
Shuai Z, Zhang H, Wang J, Li J, Ouyang M. Combined AFS and DYC control of
four-wheel-independent-drive electric vehicles over can network with timevarying delays. IEEE Trans Veh Technol 2014;63(2):591602.
Hartwich F, Mller B, Fhrer T, Hugel R. Timing in the TTCAN network; 2014.
<http://www.control.aau.dk/jdn/edu/doc/eldbus/Timing_in_TTCAN.pdf>.
EPSG DS 301 V1.2.0 POWERLINK communication prole specication; 2013.
openPowerlink an open-source POWERLINK protocol stack; 2015. <http://
openpowerlink.sourceforge.net/web/openPOWERLINK.html>.
Raspberry Pi; 2015. <http://www.raspberrypi.org/>.

Please cite this article in press as: Jatzkowski J, Kleinjohann B. Self-reconguration of real-time communication in cyber-physical systems. Mechatronics
(2015), http://dx.doi.org/10.1016/j.mechatronics.2015.04.014