Internet-based Control of a Ball-and-Plate System: a
Case Study of Modeling and Automatic Code
Generation for Networked Control Systems
Gina Torres, Enric X. Martı́n, Manel Velasco, Pau Martı́
Antonio Camacho
Automatic Control Department
Technical University of Catalonia
Pau Gargalla 5, 08028 Barcelona, Spain
Email: {gina.torres,manel.velasco,pau.marti}@upc.edu
Department of Electronic Engineering
Technical University of Catalonia
Av. Victor Balaguer s/n, 08800 Vilanova i la Geltrú, Spain
Email: [email protected]
Abstract—The evolution of technology and application needs
leads to design complex systems both at hardware and software
levels. Modeling approaches and automatic code generation are
mature techniques in several application areas to shorten development times even in complex applications. This paper introduces
the application of these techniques to critical embedded systems
such as networked control systems (NCS). In particular, the case
of an Internet-based control of a ball&plate system is presented.
The first part of the paper is devoted to the plant modeling
and control design strategy taking into account the distributed
layout. The second part covers the automatic code generation
process: from ScicosLab diagrams, C code is automatically
generated onto multiple and physically distributed threads, with
the automatic synthesis of thread scheduling, communication and
access to the I/O primitives for sampling and actuation. The
case study corroborates that model-based design tools mastering
NCS complexity can contribute to the success of future industrial
projects.
I. I NTRODUCTION
Analysis, design and implementation of safety-critical embedded systems is a complex task that demands expertise in
several engineering disciplines and covering complementary
aspects related to the hardware and the software. The falling
cost of hardware leads to greater system complexity since
it allows larger, more powerful systems to be built. Custom
hardware is not an issue anymore, and software is becoming
dominant in embedded system design. The challenge is then
to correctly design these systems.
Development tool-sets including high-level modeling with
automatic code generation can be used to simplify the task of
building these systems. Different perspectives and application
domains of these approaches can be seen for example in [1]–
[5]. And a recent state-of-the-art review of software engineering for automation systems can be found in [6], showing that
automatic code generation is now a vastly deployed technique
to translate high-level representations in the form of models
to a source code implementation.
This paper introduces the application of these techniques to
networked control systems (NCS) where sensors, controllers
and actuators may be implemented in physically distributed
Fig. 1.
Scheme of the networked control of a B&P
nodes that exchange control data over a communication network. State-of-the-art review of NCS can be found for example
in [7] or [8].
The case of a networked control of a ball&plate (B&P)
system, illustrated in Figure 1, is presented. The B&P system
has been traditionally used to explore various control techniques to maintain the ball in a quasi equilibrium position
over an oscillating plate. The ball can either remain at a fixed
reference point or it can trace a pre-determined path (see e.g.
[9], [10]). The paper summarizes the plant modeling effort,
and the controller design process is developed taking into
account the distributed architecture of the networked setup
(an extended explanation can be found in [11]). In particular, a
node, named S/A-node, performs sampling and actuation while
another node, named C-node, acts as a controller, and they
exchange control data through Ethernet [12] and the associated
Internet protocols IP (Internet Protocol) [13] and UDP (User
Datagram Protocol) [14]. The Ethernet network, enabled by a
switch, has Internet connectivity, connects a personal computer
(PC) for monitoring purposes, and offers other connections to
further distribute the control loop operation if required.
With the evolution of the Internet towards higher Qualityof-Service, the original Ethernet protocol has been enhanced
and completed with new standards that fill most of the
requirements for an industrial solution [15]. Hence, these
technologies can be successfully applied to NCS as shown in
many approaches such as [16]–[21]. However none of them
have applied model-based design tools. Modeling languages
Fig. 2.
NCS testbed
allow domain experts developing a software solution using
a set of tools developed to solve a specific problem. An
automatic code generator is the key element to bridge the gap
between a model abstraction and a source code implementation
by providing a correct-by-construction result.
The case study reported in this paper makes use of the
tools presented by [5] that were designed and realized for
the extension of the simulation and modeling capabilities and
the automatic generation of code from ScicosLab models [22]
running on embedded OSEK/VDX-Erika [23], [24], Linux
with pthread libray [25], and RTAI [26] systems. Within
the tool-set, the work described in this paper makes use
of the E4Coder code generator [27], a framework based on
model-to-model and model-to-code transformation techniques.
It provides support for datatypes, efficient code in-lining and
generation of a mutithreaded implementation of multirate
models, with the automatic synthesis of thread scheduling,
communication and access to the I/O primitives for sampling
and actuation.
The rest of this paper is organized as follows. Section II
describes the components of the NCS, namely the plant, the
network and the controller. Section III describes the modeling
and automatic code generation process for the NCS. Section
IV discusses the results. And Section V concludes the paper.
II. NCS: D ESCRIPTION AND D ESIGN
The NCS testbed considered in this paper is shown in
Figure 2. It has three main components: the Ball&Plate plant,
two training boards acting as S/A-node and C-node, and the
Ethernet network (and switch). Ethernet and related issues will
not be explained here except for those required details.
A. Ball&Plate System and Model
The B&P plant is the Amazing ball from Evidence Srl [28].
The physical system consists of a steel plate pivoted on
a central joint that allows simultaneous rotation on the x
and y directions. The system has two degrees of freedom
ensured by two servomotors placed in such a way (shafts
are perpendicular) that permit to control the plate angle in
the x and y coordinates. The servomotors model is HS-311,
from Hitec. They rotate in both directions, and the maximum
rotation angle is 90 deg. It admits between 4.8 − 6V, and with
6V takes 0.15s to rotate 60 deg (without load) and presents a
variable
mb
xb
ẋb
yb
ẏv
Ib
ωx
ωy
rb
Ip
θx
θy
θ̇x
θ̇y
h
g
units
[kg]
[m]
[m/s]
[m]
[m/s]2 kg · m
[rad/s]
[rad/s]
[m] 2 kg · m
[rad]
[rad]
[rad/s]
[rad/s]
[m]2 m/s
description
ball mass
ball position in the x-axis
ball linear velocity along the x-axis
ball position in the y-axis
ball linear velocity along the y-axis
ball inertial moment
ball angular velocity in the x-axis
ball angular velocity in the y-axis
ball radius
plate inertial moment
angle between x-axis and horizontal plane
angle between y-axis and horizontal plane
plate angular velocity in the x-axis
plate angular velocity in the y-axis
ball eight
gravity g = 9.81m/s2
TABLE I
VARIABLES USED TO DESCRIBE THE PHYSICAL SYSTEM
torque of 3.7Kg/cm. The angular position of each servomotor
is transmitted to the plate using three bars connected to two
rotary articulations.
The Ball position (in x and y coordinates) is captured by
a high resolution, 4-cable, 215x160mm resistive touchscreen
(from Hantouch) mounted on the plate. The ball position is
transmitted in analog format and pixels units. The relation
between pixels and meters is 8.8·10−4 . The ball is completely
spherical, with a radius of 15mm and a mass of 0.2kg.
The control design procedure requires a mathematical model
that can be derived from the differential equations capturing
the physical behavior of the B&P. The B&P is a typical
non-linear system whose precise mathematical model is hard
to obtain. Modeling, control and implementation approaches
for the B&P system characterized by different physics, approached with different modeling techniques, or controlled
using different strategies can be found in the literature (see
[11] for a survey). The ball dynamics with respect to the plate
through the inclination angles is given by [11]
Ib
mb + 2 ẍb − mb θ̇x (xb θ̇x + yb θ̇y ) + mb g sin θx = 0
rb
Ib
mb + 2 ÿb − mb θ̇y (xb θ̇x + yb θ̇y ) + mb g sin θy = 0
rb
where the description of each term is shown in Table I.
These equations describe how the acceleration of the ball
movement depends on the angles and angular velocity of the
plate inclination. Defining as state variables the ball position
and velocity in both coordinates, xb , ẋb , yb and ẋb , and
considering that an approximation for the ball inertial moment
is given by Ib = 25 mb rb2 the ball dynamics can be re-ordered
as state equation in continuous-time state-space form as
ẋ1 = x2
5
ẋ2 = (x1 θ̇x2 + x3 θ̇x θ̇y − g sin θx )
7
ẋ3 = x4
5
ẋ4 = (x3 θ̇y2 + x1 θ̇x θ̇y − g sin θy )
7
(1)
which indicates that the ball radius and weight are properties
that do not affect to the systems dynamics. And noting that
the B&P output is the ball position, the continuous-time state
space output equation can be written as
x1
y=
(2)
x3
The oscillatory plate receives the position and movement
produced by the servomotors through the articulated bars. The
analysis of these bars permit to obtain the relation between the
motor angular position and the plate inclination.
Servomotors are the plate actuators since they allow changing the plate angle. It should be noticed that the servomotor
has its own tuned controller (inner-control) that ensures an
accurate positioning and therefore only admits updates in the
reference. The inner-control provides a timing constraint to
the B&P control system (outer-control). The reference for the
servomotor can be only updated every 20ms. Therefore, this is
the minimum smpling period available for the B&P controller
that has to be designed.
The complete mathematical model for the B&P system
consists on the series connection of the servomotors, the
articulated bars, and the ball & plate (1)-(2) models. The inputs
to the plant are voltages applied to each servomotor in the form
of PWM and the output is the ball position in terms of the x
and y coordinates. It is a complex and highly nonlinear MIMO
(multiple input/multiple output) system. In order to simplify
the control design process, a simpler model may be desirable.
To simplify the model, the following observations are considered. If the closed-loop poles placed by the B&P controller
provide a slower dynamics than the one exhibited by the
servomotors, the servomotors dynamics can be considered
negligible in the model used for controller design. In addition,
the articulated bars only add a gain and offset, but they
do not impose extra dynamics. Overall, the model can be
approximated by [11]
ẋ1 (t) = x2 (t)
5
ẋ2 (t) = − g sin ux (t)
7
(3)
ẋ3 (t) = x4 (t)
5
ẋ4 (t) = − g sin uy (t)
7
where state variables x1 and x2 and input ux represent xb , ẋb
and θx for the x-motion case, and x3 , x4 and uy represents
yb , ẏb and θy for the y-motion case, respectively. Note that
the model presented is decoupled in each axis.
B. Networked Nodes and Controller Design
The two development boards, S/A-node and C-node, are
also from Evidence. Each one is composed by a mother board
containing a dsPIC33FJ256MC710 microcontroller and five
daughter boards that facilitate the interaction with the physical
set-up and the remote communication.
The networked control operation will be as follows. The
node attached to the B&P (recall the testbed shown in Figure
2) will act as a S/A-node. Therefore, at a given periodicity
it will obtain the ball position for each coordinate, xb or
yb , and it will send this information using an UDP message
to the C-node. Complementary, the S/A-node will apply the
control signal for each coordinate, θx or θy , obtained from an
incoming UDP message sent by the C-node. And the C-node
will be in charge of receiving the ball positions, computing
the control algorithm to obtain the new servomotors angles,
and sending them to the S/A-node.
The control algorithm can serve different goals: to position
the ball on the plate in a given coordinate, e.g., the plate center,
or to track a reference signal. In both cases a suitable controller strategy can be obtained applying feedback linearization
techniques to (3). In particular, discretization of a continuous
time control design is applied, which implies designing in the
continuous-time domain, and then approximating the design
by a discrete-time controller through fast sampling that will
be executed periodically according to a selected sampling
period h.
Considering the constraints posed by the servomotor in
terms of timing, the shortest sampling period giving the fastest
reasonable sampling for the B&P can not be smaller than
20ms. In addition, by studying the servomotors dynamics
experimentally, it can be concluded that the servomotor inner poles are around −25. Hence, considering the previous
discussion, it is reasonable to choose a desired location of
the continuous-time outer closed loop poles at s = −2.5.
In this way, the servomotors dynamics (inner loop) are made
negligible compared to the B&P desired dynamcis. In addition,
by using the rule-of-thumb that indicates that for first order
systems an appropriate approach to select the sampling period
h is to take from 4 to 10 samples per rise time [29], the feasible
range of values when τ = 1s is 40ms ≤ h ≤ 100ms. Hence,
looking for fast sampling, h = 40ms is selected for the design
and implementation of the controller.
The controller design approach is based on continuous-time
input-output linearization. Looking at (3), it is straightforward
to observe that only input transformation, u = u(x, v) (and not
state transformation) is required to obtain the linear relation
between the input and the output. In fact, the nonlinearities
can be canceled by the control law of the form
v(t)
u(t) = arcsin
(4)
− 57 g
where v(t) is the equivalent input to be designed, leading to
a linear input/output double integrator relation given by
ẋ1 (t) = x2 (t)
ẋ2 (t) = v(t)
y(t) = x1 (t)
(5)
Since the new dynamics (5) are linear and controllable, it is
well known that the linear state feedback control law with
the form v(t) = −Lx(t) can place the closed loop poles
s1,2 anywhere with proper choice of the feedback gain L.
However, since the control input will operate with discretetime measurements, the discrete-time form of the linear control
will be used in (4), which leads to
d
L x(tk )
, t ∈ [tk , tk+1 [
u(t) = arcsin
5
7g
Algorithm 1: Sampling at S/A-node (triggered every h)
(6)
where Ld , obtained from the discretization of the continuoustime linear system (5) with sampling period h = 0.04s, is
given by
Ld = 5.6599 4.6449
if the continuous-time poles are placed at s1,2 = −2.5 as
previously discussed.
For implementing (6), full state x(tk ) measurement is
necessary. However, only the ball position, x1 (tk ), is available
from measurements. Hence, the ball velocity, x2 (tk ), must
be obtained using suitable strategies. The adopted one is a
full-order observer
that will reconstruct
the entire state vector
T
x̂1 (tk ) x̂2 (tk )
, ball position and velocity,
x̂(tk ) =
using only measurements of the ball position, x1 (tk ).
The observer is designed in the discrete-time domain from
the linearized approximation of the non-linear system (3) at the
equilibrium point of interest. It is interesting to observe that
any point of the touch screen is an equilibrium point which
means that the system has an infinity of equilibrium points
(x∗ , u∗ ) characterized by any ball position x∗1 (t) = xp and
zero velocity, x∗2 (t) = 0, with u∗ = 0. The continuous time
linear model approximation for (3) for example around (0, 0)
is
0
0 1
u(t)
(7)
ẋ(t) ≃
x(t) +
0 0
− 57 g
Note that for any other equilibrium point characterized by
xp 6= 0, the linear approximation (7) still holds if xp is
subtracted from x(t). The output equation in (3) remains the
same for the model approximation (7), that is
y(t) = 1 0 x(t).
(8)
A discrete-time full observer obeys the equation [29]
x̂(tk+1 ) = Φ(h)x̂(tk ) + Γ(h)u(tk ) + Lp (y(tk ) − ŷ(tk ))
ŷ(tk ) = C x̂(tk )
(9)
where Φ(h) and Γ(h) are the discrete-time system and input
matrices of (7)-(8) if sampled with h = 0.04s, and the Lp
is the observer proportional gain. The gain is designed via
pole placement to achieve satisfactory observer error xe (tk ) =
x(tk ) − x̂(tk ) dynamics. As a rule of thumb, if sensor noise
is large, like in the case of the measurements given by the
touch screen in the B&P, the estimator poles should not be
very fast in order to avoid amplifying the noise, leading to a
system with lower bandwidth and more noise smoothing [29].
Remembering that the faster controller poles were placed at
s1,2 = −2.5, the observer poles are place at sp1,2 = −5. With
these specifications, the discrete time observer gain is
0.3625
Lp =
0.8215
1
2
3
4
begin
xk := ADC get ball position()
UDP send(C-node, xk )
end
Algorithm 2: Control algorithm computation
at C-node (triggered on message RX)
1
2
3
4
5
begin
xk := UDP receive()
uk := compute control signal(xk )
UDP send(S/A-node, uk )
end
Algorithm 3: Actuation at S/A-node (triggered on message RX)
1
2
3
4
begin
uk := UDP receive()
PWM apply control signal(uk )
end
Fig. 3.
Pseudo-codes for the NCS
III. M ODELING AND AUTOMATIC C ODE G ENERATION
This section explains the modeling process of the B&P
control in ScicosLab for automatic code generation. Note
that otherwise the standard approach would be to implement
the distributed control application from scratch, which means
programming all the required components such as clock, timer,
interrupts, PWM, ADC, UDP communications, etc... and finally implementing the control strategy. The implementation
of the control strategy could be summarized as shown in
Figure 3. However, rather than following this path, E4Coder
for automatic code generator will be used.
E4Coder is packaged as a ScicosLab toolbox. For this
reason, it must be loaded from the ScicosLab Toolbox Menu.
It provides a set of customized ScicosLab blocks that can
be used for simulating a design and for code generation.
Among them, the “Code Generation Properties” (CGP) block
is used to store all the configuration needed to generate the
code, storing for example the mapping between superblocks
and real-time operating system tasks, as well as the mapping
between generic I/O blocks and the real peripherals on the
target. The I/O blocks, such as ADC or PWM blocks, are
generic because the mapping between the specific block and
the peripheral really used on the target is defined only at code
generation time.
To simulate and automatically generate code for the networked control strategy explained previously, two ScicosLab
diagrams are designed, one for the C-node and another one for
the S/A-node. The diagram for one node is shown in Figure
4, and it contains the standard ScicosLab supeblock plus the
E4Coder CGP block, that will be explained later.
Fig. 7.
Fig. 4.
Definition of tasks
A ScicosLab diagram with the “Code Generation Properties” block
Fig. 8.
Fig. 5.
Detail of the sampling/actuation diagram
Fig. 6.
Detail of the controller diagram
Figures 5 and 6 show the main diagrams for an example of
the S/A-node and C-node respectively. The S/A diagram, is
driven by the clock shown in the previous diagram of Figure
4, which defines the periodicity for the simulation, e.g., 40ms.
Looking at the S/A diagram from left to right, it can be seen
that the ball position is given by the E4Coder “Touch” I/O
block that models the resistive touchscreen. At each sampling
time, the block outputs two integer values representing the
latest xb and yb position read from the touchscreen in pixels.
After converting them to float, converting from pixels to
meters, and performing a basic filtering to try to eliminate
the noise from the position measurements, the data is sent in
this diagram using two UDP messages. The configuration of
the network is made through the “FLEX UDP Config” block
as also shown in Figure 5.
Figure 5 also shows the actuation part of the ScicosLab
diagram. As defined in the control design, the servomotor
angles are received by the S/A node through for example two
UDP messages. After applying a correction due to the plate
morphology, angles are applied to servomotors using E4Coder
“PWM” I/O blocks.
Input/Output configuration
Figure 6 shows the basic diagram for the C-node. The
inputs and outputs are given by the UDP communication. The
diagram contains a block that implements the observer and
controller for each coordinate, and then, the resulting control
signal, that is, the angles, are sent via UDP to the S/A-node.
The observer and controller block initially implements the
designs explained before.
Once the controller design has been validated by simulation,
automatic code generation can start. A Scicos diagram is the
input information for E4Coder to generate C functions, named
Runnables, that can be then compiled for the target system, i.e.,
dsPIC33FJ256MC710 micro-controller. For Erika, the code
generator through the CGP block allows the specification of
a task set, as illustrated in Figure 7. Each task has a period,
which is used to configure a per-task periodic timer (a periodic
alarm in the OSEK/VDX context). In this case, it is the task
in the S/A-node, which executes every 40ms (as designed and
simulated).
The CGP block also allows to the specification of a mapping
between the generic peripheral I/O blocks and the actual
peripheral available in the target board. The tool allows the
selection among a list of supported boards, and allows the
possibility to map each peripheral to a specific instance of the
same kind available in the target board. Figure 8 illustrates the
case of the S/A-node. The selected board is the FLEX motion
board (FLEX MTB SERVOMOTOR) that is attached to the
B&P (remind Figure 2) and the I/O blocks to be mapped are
the touch screen and PWM modules.
IV. R ESULTS
The controller design and the automatic code generation
from ScicosLab diagrams have permitted to successfully implement the Internet-based control of the B&P. Figure 9 shows
for example the dynamics of the ball on the plate for the xmotion in the case that the control objective
is to
T place the
ball in the center of the plate, i.e. x∗ = 0 0
m, and it
T
starts from an initial condition x0 ≈ −0.075 0
m. The
R EFERENCES
Fig. 9.
Fig. 10.
Ball dynamics
New ball dynamics
left sub-figure shows that the ball goes to the desired position
with the expected dynamics and the right sub-figure shows the
estimated velocity dynamics.
Complementary, Figure 9 shows a different ball dynamics.
They are produced by a re-design where the control objective
has been to have the ball tracking a reference signal (a square
path on the plate) imposing an oscillatory dynamics.
V. C ONCLUSIONS
This paper has shown the application of E4Coder for the
design and implementation of networked control systems.
Firstly, the B&P plant model and the controller design have
been described. The use of ScicosLab diagrams and the
automatic code generation facility removes the always tedious
programming effort. But more important, it permits to modify
and improve designs at the simulation time, and then generate
the new C code with just a “click”, which makes very fast the
implementation of several designs. The time-saving increase
when the implementation require programming several microcontrollers, as in the case of NCS.
The bennefits of modeling and automatic code generation
can be extended to many real applications where simplifying
and reducing the time development is a must. These bennefits
are particularly interesting in NCS since the complexity of
these kind of systems is higher. To further explode the capabilities of automatic code generation in real applications, some
features are open for future work, as for example the analysis
of complex behaviour in NCS due to relevant delays between
sampling and actuation, the sharing of the communication
network with non-control messages, the bandwidth utilization
an optimization, etc. All these future research topics can be
easily and fastly analyzed by the deployment of an automatic
code generation testbed as presented here.
ACKNOWLEDGMENT
This work has been partially supported by EVENTS Event-Driven Embedded and Networked Control Systems,
DPI2010-18601, 2011-2013/14.
[1] M. Di Natale, Liangpeng Guo, Haibo Zeng and A. SangiovanniVincentelli, “Synthesis of Multitask Implementations of Simulink Models
With Minimum Delays,” IEEE Trans. Ind. Informatics, v.6, n.4, pp.637651, 2010
[2] E. Estevez and M. Marcos, “Model-Based Validation of Industrial Control
Systems,” IEEE Trans. Ind. Informatics, vol.8, no.2, pp.302-310, 2012.
[3] S. Rosch, D. Schutz, G. Bayrak and B. Vogel-Heuser, “Supporting integrated development of closed-loop PLC control software for production
systems,” in 38th Annu. Conf. on IEEE Ind. Electron. Soc., Oct. 2012
[4] L. Abele and S. Grimm, “Knowledge-based integration of industrial plant
models,” in 39th Annu. Conf.on IEEE Ind. Electron. Soc., Nov. 2013
[5] B. Morelli, R. Schiavi, C. Scordino, P. Gai and M. Di Natale, “Automatic
generation of controls code from models for real-time Linux platforms”,
15th Real-Time Linux Workshop (RTLWS), Switzerland, 2013.
[6] V. Vyatkin, “Software Engineering in Industrial Automation: State-ofthe-Art Review,” IEEE Trans. Ind. Informatics, vol.9, no.3, pp.1234,1249,
Aug. 2013
[7] P. Antsaklis and J. Baillieul, “Special issue on technology of networked
control systems”, Proceedings of the IEEE, vol. 95 n.1, 2007
[8] R.A. Gupta and M.-Y. Chow, “Networked Control System: Overview and
Research Trends,” IEEE Trans. Ind. Electron., vol.57, no.7, pp.2527-2535,
July 2010.
[9] D. Casagrande, A. Astolfi and T. Parisini, “Switching-Driving Lyapunov
Function and the Stabilization of the Ball-and-Plate System,” IEEE Trans.
on Automatic Control, vol.54, no.8, pp.1881-1886, Aug. 2009
[10] D. Yuan and Z. Zhang, “Modelling and control scheme of the ball-plate
trajectory-tracking pneumatic system with a touch screen and a rotary
cylinder,” IET Control Theory & Applications, vol.4, no.4, pp.573-589,
April 2010.
[11] G. Torres, A. Fernandez, M. Tudela, A. Camacho, E.X. Martı́n, M.
Velasco and P. Martı́, “Controlling Ball-and-Plate System: Analysis, Design, and Implementation,” Research report ESAII-RR-14-02, Automatic
Control Department, Technical University of Catalonia, Apr. 2014.
[12] “Ethernet Standard,” IEEE 802.3-2012. IEEE Standard for Ethernet
[13] “Internet Protocol,” Internet Engineering Task Force (IETF), IETF RFC
791, Sep., 1981
[14] “User Datagram Protocol,” Internet Engineering Task Force (IETF),
IETF RFC 768, Aug., 1980
[15] J-D. Decotignie, “Ethernet-Based Real-Time and Industrial Communications,” Proceedings of the IEEE , vol.93, no.6, pp.1102-1117, June 2005
[16] Senchun Chai, Guo-Ping Liu, D. Rees, and Yuanqing Xia, “Design and
Practical Implementation of Internet-Based Predictive Control of a Servo
System,” IEEE Trans. Control Systems Technology, vol.16, no.1, pp.158168, Jan. 2008
[17] R. Wirz, R. Marin, M. Ferre, J. Barrio, J.M. Claver and J. Ortego,
“Bidirectional Transport Protocol for Teleoperated Robots,” IEEE Trans.
Ind. Electron., vol.56, no.9, pp.3772- 781, Sept. 2009
[18] G. Pin and T. Parisini, “Networked Predictive Control of Uncertain
Constrained Nonlinear Systems: Recursive Feasibility and Input-to-State
Stability Analysis,” IEEE Trans. on Automatic Control, vol.56, no.1,
pp.72-87, Jan. 2011
[19] S. Minyoung, K. Kanghee, J. Hyun-Wook and K. Taehyoun, “An
EtherCAT-based motor drive for high precision motion systems,” in 9th
IEEE Int. Conf. on Ind. Informatics, July 2011
[20] N. Bibinagar and K. Won-jong, “Switched Ethernet-Based Real-Time
Networked Control System with Multiple-ClientServer Architecture,”
IEEE/ASME Trans. on Mechatronics, vol.18, no.1, pp.104-112, Feb. 2013
[21] M. Diaz-Cacho, E. Delgado, and A. Barreiro, “Internet delays and packet
losses sensor/actuator for UDP based networked control systems,” in 21st
Mediterranean Conf. on Control & Automation, June 2013
[22] ScicosLab, www.scicoslab.org
[23] P.Gai, E.Bini, G.Lipari, M.Di Natale and L.Abeni, “Architecture for a
portable open source real-time kernel environment,” in Real-Time Linux
Workshop, 2000.
[24] Erika Enterprise - Open Source RTOS OSEK/VDX Kernel, www.erika.
tuxfamily.org
[25] Pthreads - POSIX.1c, Threads extensions (IEEE Std 1003.1c-1995)
[26] RTAI, the RealTime Application Interface for Linux, www.rtai.org
[27] E4coder - toolset for simulation and code generation for embedded
devices, www.e4coder.com
[28] Evidence s.r.l, www.evidence.eu.com/
[29] K. J. Åström, and B. Wittenmark, Computer-Controlled Systems, 1997.