Content uploaded by Murat Uzam
Author content
All content in this area was uploaded by Murat Uzam on Aug 20, 2017
Content may be subject to copyright.
An Effective Method for Detection and Elimination of Avalanche Effect Problem 1988
Murat Uzam, Gokhan Gelen, Recep Dalci
A Workshop Rescheduling Algorithm to Solve Producing Anomaly 1994
Rong Dong, Weiping He, Yajie Li
A Hybrid DPSO-SA Approach to Assembly Sequence Planning 1998
Hongguang Lv, Cong Lu, Jun Zha
Comparison Between Experimental and Computer Modelling Results for a Pneumatic/Hydraulic
Hybrid Cylinder
2004
Dyfyr Ll Davies, Yiqin Xue, John Watton, Graham A Williams
Optimal Collision Avoidance Maneuver for Formation Flying Satellites Using Relative Orbital
Elements
2009
Min Hu, Guoqiang Zeng, Junling Song
Agent-Based Real-Time Assembly Line Management for Wireless Job Shop Environment 2013
Yingfeng Zhang, George Huang, Ting Qu, Jun Hong
Sa3-6: Production Scheduling and Control
Abstract— The Supervisory control theory (SCT) is a general
framework for the synthesis of supervisors (controllers) for
discrete events systems (DES). The SCT makes use of automata
theory and formal languages. Given a plant automaton model
and a specification for the controlled behavior, a RW
(Ramagde-Wonham) supervisor is obtained as an automaton.
Programmable Logic Controllers (PLCs) are widely used in
modern industrial systems to carry out control tasks. Although
there are a lot of methods proposed for PLC based
implementation of RW supervisors, there are still very few
industrial applications. This is due to a number of important
problems, one of which is called avalanche effect. In this paper,
two contributions are provided to tackle with the avalanche
effect problem. The first one is an algorithm proposed for the
determination of the events that cause avalanche effect in a
given supervisor. The second one is a very simple and effective
avalanche effect elimination method (AEEM). The applicability
of these two contributions is shown by examples.
I. INTRODUCTION
HE Supervisory control theory (SCT), based on finite
state machines (FSM) and formal languages, is a general
theory to design controllers (supervisors) for discrete
event systems (DES) [1, 2]. In SCT, given an uncontrolled
model of the system and the desired system behavior
specifications, the objective is to synthesize a supervisor
(controller) such that the controlled behavior of the system
does not contradict the specifications given and does not
unnecessarily constrain the behavior of the system.
Programmable Logic Controllers (PLCs) have been widely
used in modern industrial systems to carry out control tasks.
The PLC based implementation of supervisors (in automaton
form) has been studied by many researchers [3-14]. In [3-7],
the application of SCT to flexible manufacturing cells and
PLC based implementations are studied. In [8-9], local
modular supervisors and their PLC based implementations
are considered. Implementation of supervisors are proposed
in LLD (Ladder Logic Diagram) code [8] and sequential
function charts (SFC) [9]. The main feature of these works is
that the control system is used as an interface between the
real input-output signals and theoretical supervisors [8-10].
In [11, 12], the conversion of finite state machines
Manuscript received March 17, 2010. This work was supported by the
research grant of The Scientific and Technological Research Council of
Turkey (Türkiye Bilimsel ve Teknolojik Aratrma Kurumu - TÜBTAK)
under the project number TÜBTAK-107E125.
All Authors are with Nide Üniversitesi, Mühendislik Mimarlk Fakültesi,
Elektrik-Elektronik Mühendislii Bölümü, Kampüs, Nide, TURKEY.
(M. Uzam is the corresponding author phone: +90 388-225-22-82; fax: +90
388-225-01-12; e-mail1: murat_uzam@nigde.edu.tr; e-mail2:
murat_uzam@hotmail.com; http://host.nigde.edu.tr/muzam).
(automaton) to LLD is proposed. The LLD implementation
of finite state machines is studied in [13]. In a recent work
[14], a new approach is proposed for the LLD
implementation of supervisors. The method of [14] deals
mainly with the assignment of actions (output signals) to the
related states of supervisors.
The problems and possible solutions for PLC
implementation for supervisors in automaton form are
discussed in [15]. An important problem, called avalanche
effect, makes the program skip over an arbitrary number of
states during the same PLC scan cycle. In [15], arranging
PLC code rungs in the reverse order is proposed as a simple
solution for this problem. But, this not a general solution
and may fail in some cases [16]. In order to solve the
avalanche effect problem, a general method based on
expressing automata in logical domain is proposed in [16].
The disadvantage of the method proposed in [16] is that it
requires two memory elements, i.e. Boolean variables, for
implementing each state of a supervisor. This is a big
problem especially when implementing a supervisor with a
huge number of states in a PLC with very limited memory
resources. In this paper, a new method is proposed for the
detection and elimination of avalanche effect problem. There
are two contributions of this paper. In the former, an
algorithm is proposed for the determination of the events
that cause avalanche effect in a given supervisor
(automaton). In the latter, a very simple and effective
avalanche effect elimination method (AEEM) is proposed.
The applicability of these two contributions is shown by
examples.
The remainder of this paper is organized as follows:
Section 2 provides preliminary information about automata
and avalanche effect problem. In Section 3, an algorithm is
proposed for the detection of events that cause avalanche
effect in a given automaton. The implementation
methodology that eliminates avalanche effect problem is
proposed in Section 4. The applicability of the proposed
methodology is demonstrated by means of an illustrative
example in Section 5. Finally, conclusions are given in
Section 6.
II. AVALANCHE EFFECT PROBLEM
The supervisory control theory (SCT) was introduced to
extend control theory concepts for continuous systems to the
discrete event environment [1, 2]. The SCT makes use of
automata theory and regular languages for modeling system
behavior. In SCT, plant and specifications that represent
controlled behavior of plant can be modeled as automata. A
Ramadge-Wonham (RW) supervisor is obtained as an
automaton which can affect the operation of plant in order to
An Effective Method for Detection and Elimination of
Avalanche Effect Problem
Murat UZAM, Gökhan GELEN, Student Member, IEEE, and Recep DALCI
T
978-1-4244-5141-8/10/$26.00 © 2010 IEEE 1988
Proceedings of the 2010 IEEE
International Conference on Mechatronics and Automation
August 4-7, 2010, Xi'an, China
avoid forbidden behaviors. Discrete event systems evolve on
spontaneously occurring events. Let ¦ be finite set of events.
The set of all finite concatenations of events in ¦ is denoted
by ¦*. An element of this set is called a string. The number of
events gives the length of the string. The string with no
element is denoted by ε and is called empty string. A subset
L ⊆ ¦* is called a language over ¦. For a string s∈¦*, s
denotes the prefixes of s and is defined as s= {sp∈ ¦* | ∃t ∈
¦* (spt=s)}. Extension of this definition to language prefix
closure of a language L is denoted by L. A language L
satisfying the condition L= L is said to be prefix closed. An
automaton, denoted by G, is a six-tuple G=(Q, ¦, f, , q0,
Qm) where, Q is the set of states, ¦ is the finite event set, f:
QצQ is the partial transition function. : q 2¦ is the
active event function. (q) is the set defined for every state of
G and represents the feasible events of q. q0 is the initial
state and Qm ⊆ Q is the set of marked states representing the
completion of a given task or operation. A simple automaton
model with two states is shown in Fig. 1. This automaton has
two states labeled with q0 and q1. q0 with a double arrow is
the initial (and marked) state, while q1 with an exiting arrow
is the marked state of the automaton. A directed arrow
represents the transition functions of the automaton. Labels
of transitions (e1, e2) correspond to events.
q0 q1
e1
e2
Fig. 1. A simple automaton model.
In PLC implementation of a supervisor (automaton),
states are represented by Boolean variables and events can
be defined as rising or falling edges of the signals. For such
definition of events --|P|-- (positive transition sensing
contact) and --|N|-- (negative transition sensing contact) can
be used respectively. Some symbols of IEC 61131-3 LD
(Ladder Diagram) PLC programming language [18] used in
this paper are depicted in Table 1. The conversion of a
supervisor into LLD code for PLC implementation is a
straight forward process. From the literature one can find
some well-established methods. The following briefly
explains the method utilized in this paper [14]: a Boolean
variable (a memory bit) is assigned to each state of the
supervisor. Initially, the Boolean variable representing the
active (initial) state is SET and all other Boolean variables
representing the rest of the RW supervisor states are RESET.
Then, each transition between states of the supervisor is
implemented as a separate PLC ladder rung by using SET
and RESET commands. When associating events with rising
and falling edges of signals, care must be taken not to skip
over an arbitrary number of states during the same scan
cycle. This is called the avalanche effect and is a
consequence of the sequential evaluation of the Boolean
expressions [15]. For example consider the automaton
shown in Fig. 2. The automaton moves from state q0 to q1
on the occurrence of ‘a’. Then it is supposed to move from
q1 to q2 on the new occurrence of ‘a’. If a ‘b’ occurs before
another ‘a’ then it moves from q1 to q3. Thus this automaton
represents two strings ‘aa’ and ‘ab’ [15]. LLD
implementation of this automaton shown in Fig. 3.(a) does
not mimic this behavior. Rather, the avalanche effect
problem causes a direct transition from q0 to q2 on the same
rising edge of the signal ‘a’. One simple cure for this
problem is to arrange the rungs in the reverse order [15]. In
this particular example if the rungs 2 and 3 of the LLD code
shown in Fig. 3.(a) are arranged in the reverse order as
shown in Fig. 3.(b), then the problem is solved. However,
this methodology is highly dependent on the problem at
hand, and may fail in some cases. As an example, a simple
automaton is given in Fig. 4 [16]. Obviously, event ‘a’
causes the avalanche effect problem: when state q0 is active,
an occurrence of event ‘a’ causes a transition to q1 and then
back to q0 in the same PLC scan cycle. Therefore the above
mentioned simple method does not solve the avalanche
effect problem for this automaton [16].
Fig. 2. An example automaton represents two strings ‘aa’ and ‘ab’ [15].
S
q0
M0
R
q1
R
q2
R
q3
S
M0
q0
S
R
q1
q0
P
a
q1
S
R
q2
q1
P
a
q1
S
R
q3
q1
P
b
[q0, a, q1]
[q1, a, q2]
[q1, b, q3]
Init.
1
2
3
4
a) b)
Fig. 3. LLD implementations of the automaton shown in Fig. 2: a) LLD
implementation represents only the occurrence of a single ‘a’. b) LLD
implementation represents the occurrence of both strings ‘aa’ and ‘ab’.
Fig. 4. An example automaton with avalanche effect problem [16].
1989
TABLE I.
SOME SYMBOLS OF IEC 61131-3 LD LANGUAGE
Symbol Description
I Input location
Q Output location
M Memory location
***
Normally open contact
The state of the left link is copied to the right link if the
state of the associated Boolean variable (indicated by
***) is ON. Otherwise, the state of the right link is
OFF.
***
Normally closed contact
The state of the left link is copied to the right link if the
state of the associated Boolean variable (indicated by
***) is OFF. Otherwise, the state of the right link is
OFF.
P
***
Positive transition-sensing contact
The state of the right link is ON from one evaluation of
this element to the next when a transition of the
associated Boolean variable (indicated by ***) from
OFF to ON is sensed at the same time that the state of
the left link is ON. The state of the right link shall be
OFF at all other times.
N
***
Negative transition-sensing contact
The state of the right link is ON from one evaluation of
this element to the next when a transition of the
associated Boolean variable (indicated by ***) from
ON to OFF is sensed at the same time that the state of
the left link is ON. The state of the right link shall be
OFF at all other times.
( )
***
Coil
The state of the left link is copied to the associated
Boolean variable (indicated by ***) and to the right
link.
(S)
***
SET (latch) coil
The associated Boolean variable (indicated by ***) is
set to the ON state when the left link is in the ON state,
and remains set until reset by a RESET coil.
(R)
***
RESET (unlatch) coil
The associated Boolean variable (indicated by ***) is
reset to the OFF state when the left link is in the ON
state, and remains reset until set by a SET coil.
III. DETECTION OF AVALANCHE EFFECT PROBLEM
IN AN AUTOMATON
There are a number of software tools to compute RW
supervisors. In this paper, it is assumed that a RW supervisor
is given in an automaton form generated by TCT [17]. In
TCT, an automaton is described in an “.ADS” file. The
integer numbers are used for state labels (0, …, 2000000)
and event labels (0, …, 999). ‘0’ is used for the initial state.
In TCT, the transitions of an automaton are entered as in
“Exit_(Source)_State Transition_Label
Entrance_(Target)_State” format. For example 2 0 1 means
that, there is a transition labeled with event ‘0’ from state 2
to state 1. As a special example, 1 0 1 means that there is a
selfloop labeled with event ‘0’ on the state labeled with ‘1’.
All transitions are written as a list at the end of the file. This
transition list can be considered as a matrix. The number of
lines of this matrix is equal to the number of all transitions.
The row number of this matrix is equal to 3. The first row
consists of labels of source states, the second one contains
labels of events and the third one consists of labels of target
states. An example automaton is shown in Fig. 5, whose
TCT representation “TEST.ADS” is provided in Fig. 6 based
on the following event and state codings:
Event coding for example automaton:
automaton: a b c d e f
TCT: 1 2 3 4 5 6
State coding for example automaton:
automaton: q0 q1 q2 q3 q4
TCT: 0 1 2 3 4
Fig. 5. An example automaton with events ‘a’, ‘b’, and ‘c’ causing
avalanche effect.
Fig. 6. The format of an example .ADS file: “TEST.ADS”
The following search algorithm is proposed in this paper to
detect events that cause avalanche effect:
Algorithm Av_effect_detector: Detector for events that
cause avalanche effect.
1990
Input: An automaton model, in .ADS file format. The
automaton defined in .ADS file transition by transition. The
transitions are entered as [Exit_(Source)_State
Transition_Label Entrance_(Target)_State]. A line of this
format named as transition. The transition structure can be
considered as [n_trans x 3] array.
1) [Define] Crr_event: temporary variable to represent
Current events value, Crr_s_sts: temporary variable
to represent Current source state of an event
represented by Crr_event. Crr_t_sts: temporary
variable to represent Current target state of an event
represented by Crr_event. All_Events: array of all
events, Av_effect_list: Array of events that cause
avalanche effect, n_trans: number of transitions in
input, num_ev: number of all events, S_state: array
of source state, T_state: array of target states.
Events: array of events between source and target
state in the same index.
2) [Initialize] Crr_event=0, i=0, j=0, k=0, index=0;
3) Crr_event=All_Events[i] take an event from all event
list
4) If (Crr_event==Events[j]) find the source and target
state of Crr_events
Then Crr_s_sts=S_state[j] and
Crr_t_sts=T_state[j];
5) (If there is a target state equal to current source state
or a source state equal to current target state and the
events of these states is equal to current event in
two cases, the current event causes avalanche
effect:)
if(((Crr_s_sts==T_state[k])||(Crr_t_sts==S_state[k]))
&&(Crr_event==Events[k]))
then
Av_effect_list[index]=All_Events[i]
index=index+1
go to step 9
end if.
6) k=k+1;
7) if (k<n_trans) goto Step 5;
8) j=j+1 and if (j<n_trans) goto Step 4;
9) k=0, j=0, i=i+1, and if (i<num_ev) goto Step 3;
Output: Av_effect_list: The set of events that cause
avalanche effect.
end Algorithm Av_effect_detector.
The main feature of this algorithm is to find at least two
successive transitions whose events are the same. The above
algorithm was implemented in C code. Then the C code was
compiled and named as “Av_effect_detector.exe”. In the
code, the .ADS file is read and the transition list is converted
into a matrix. The self-looped transitions, whose source and
target states are the same, are ignored. Because, they do not
cause a state change, i.e. avalanche affect problem. If there
are events causing avalanche effect then these events are
reported on the screen and at the same time as they are
written in a log file called “logfile.txt”. When
“Av_effect_detector.exe” program was run and the above
mentioned automaton called TEST.ADS was given as input
to check whether there is avalanche effect problem in this
automaton, the screenshot of this program was provided by
the “Av_effect_detector.exe” as seen in Fig. 7. This means
that there is avalanche effect problem in the automaton,
shown in Fig. 5, represented by TEST.ADS, and events
labeled with “1, 2 and 3”, i.e. events ‘a’, ‘b’ and ‘c’, cause
avalanche effect.
Fig. 7. The screenshot of “Av_effect_detector.exe” program
for the input “TEST.ADS”.
IV. AN EFFICIENT METHOD FOR ELIMINATION OF
AVALANCHE EFFECT PROBLEM
The avalanche effect problem occurs when a program
skips over an arbitrary number of states during the same
PLC scan cycle. The occurrence of an event can be realized
in LLD code by means of rising or falling edge of a signal.
Rising edge of a signal is detected by comparing the signal
between two consecutive scan cycles; if the signal was low
in the previous scan cycle and is now high, then a rising
edge of the signal has been detected [15]. In this paper an
efficient method is proposed for the elimination of the
avalanche effect problem when implementing an automaton
as LLD. The method is applied only to events that cause the
avalanche effect problem. Other events are treated as usual.
The proposed avalanche effect elimination method (AEEM)
involves the following steps:
1. After the initialization LLD code, SET a Boolean variable
Mi with the occurrence of each event causing the
avalanche effect problem (i= 1, 2, …, n; n: the number of
events causing the avalanche effect problem).
2. RESET the Boolean variable Mi, on each LLD rung
implementing a transition which includes the event
causing the avalanche effect problem. (i= 1, 2, …, n)
3. RESET the Boolean variable Mi at the end of the LLD
code. (i= 1, 2, …, n)
By using this method an event (the rising or falling edge
of a signal) is assigned to a memory bit Mi each time it
occurs. When Mi is set it can only be used once by one of
the two or more transitions causing the avalanche effect
problem and then it is RESET by the very transition using
Mi. If Mi is not used by one of the transitions then it is
automatically RESET at the end of the LLD code. This is a
1991
very simple and effective way of solving the avalanche
effect problem. As an example to show how this method is
applied consider the automata shown in Fig. 2. In this
automaton event ‘a’ is the cause of avalanche effect.
Therefore the AEEM is applied only to this event. The LLD
code for this automaton obtained using the AEEM proposed
is depicted in Fig. 8. In this code, the first rung initializes the
automaton by setting q0 and resetting other states q1, q2 and
q3. With the occurrence of ‘a’ M1 is set in rung 2. In rungs
3, 4, and 5 transitions [q0,a,q1], [q1,a,q2], and [q1,b,q3] are
implemented respectively. As stated before, in this
automaton transitions labeled with ‘a’ are the cause of
avalanche effect. So, M1 is reset at the end of rungs 3 and 4.
If M1 is still set, then the last rung clears the memory bit M1
for another detection of event ‘a’. As another example
consider the automaton shown in Fig. 4.(a). In this
automaton, event ‘a’ is the cause of avalanche effect. The
LLD code for this automaton obtained using the AEEM
proposed is depicted in Fig. 9. In this code, the first rung
initializes the automaton by setting q0 and by resetting q1.
With the occurrence of ‘a’ M1 is set in rung 2. In rungs 3
and 4, transitions [q0,a,q1] and [q1,a,q0] are implemented
respectively. As two transitions labeled with ‘a’ are the
cause of avalanche effect, M1 is reset at the end of rungs 3
and 4. Note that in this particular example there is no need to
reset M1 at the end of the LLD code, because M1 will be
reset either in rung 3 or in rung 4.
S
q0
M0
R
q1
R
q2
R
q3
S
M0
q1
S
R
q3
q1
P
b
[q1, b, q3]
Init.
PS
M1a
q0
S
M1
R
q1
q0
R
M1
q1
S
M1
R
q2
q1
R
M1
M1 R
recycle M1
[q1, a, q2]
[q0, a, q1]
M1
1
2
3
4
5
6
M1= a
Fig. 8. An LLD code for the automaton shown in Fig. 2
obtained by using the AEEM.
V. ILLUSTRATIVE EXAMPLE
In this section as an illustrative example, the automaton
model consisting of 5 states and 13 transitions shown in Fig.
5 is considered. There are six events, namely a, b, c, d, e,
and f. As indicated in Section 3, events labeled with a, b, and
c cause avalanche effect. Therefore in PLC LLD
implementation of this automaton the AEEM is applied only
these three events. The PLC LLD code implementation of
this automaton model can be seen from Fig. 10. The first
rung initializes the automaton by setting q0 and resetting
other states q1, q2, q3, and q4. With the occurrence of ‘a’
(respectively, ‘b’, ‘c’) M1 (respectively, M2, M3) is set in
rung 2 (respectively, rung 3, rung 4). In rungs 5, 6, …, 17,
all 13 transitions are implemented. As transition labeled with
‘a’ (respectively, ‘b’; ‘c’) is the cause of avalanche effect,
M1 (respectively, M2; M3) is reset at the end of rungs 5, 8,
12, and 15 (respectively, rungs 6, 7, and 17; rungs 9 and 11).
If M1 (respectively, M2; M3) is still set, then rung 18
(respectively, 19, 20) clears the memory bit M1
(respectively, M2; M3) for another detection of event
‘a’(respectively, ‘b’, ‘c’). All LLD codes shown in this paper
have been implemented by using a Siemens s7-300 PLC and
worked properly as expected.
S
q0
M0
R
q1
S
M0
aM1
q0
S
M1
R
q1
q0
PS
R
M1
q1
S
M1
R
q0
q1
R
M1
1
2
3
4
Init.
[q0,a,q1]
[q1,a,q0]
M1= a
Fig. 9. LLD code for the automaton shown in Fig. 4
obtained by using the AEEM.
1992
VI. CONCLUSIONS
In order to deal with the avalanche effect problem two
contributions are proposed in this paper. Firstly, an
algorithm is proposed for the determination of the events
that cause avalanche effect in a given supervisor
(automaton). This algorithm takes a supervisor as input and
if there are events in this automaton that cause the avalanche
effect problem it provides as output a list of such events.
Secondly, a very simple and effective avalanche effect
elimination method (AEEM) is proposed. The effectiveness
of AEEM lies in the fact that the method is applied only to
events that cause the avalanche effect problem. Other events
are treated as usual. This process saves an important number
of memory elements compared with the method proposed in
[16]. The applicability of these two contributions is shown
by examples. This methodology has already been applied to
low-level real-time supervisory control of an experimental
manufacturing system, which will be the topic of a further
publication.
Fig. 10. LLD implementation of the automaton shown in Fig. 5.
REFERENCES
[1] Ramadge P.J. and Wonham W.M, “The control of discrete event
systems”, Proc. IEEE, Vol.77, No. 1, pp. 81-98, January 1989.
[2] Ramadge P.J. and Wonham W.M, “Supervisory control of a class of
discrete event processes”, SIAM Journal on Control and Optimization,
Vol. 25, No. 1, pp. 206-230, 1987.
[3] B. A. Brandin, “The real-time supervisory control of an experimental
manufacturing cell,” IEEE Trans. Robotics and Automatation, vol. 12,
No. 1, pp. 1–14, February 1996.
[4] S. C. Lauzon, A. K. L. Ma, J. K. Mills, and B. Benhabib, “Application
of discrete event system theory to flexible manufacturing”, IEEE
International Conference on Robotics and automation in Nagoya,
Japan, 1996.
[5] S. C. Lauzon, J. K. Mills, and B. Benhabib, “An implementation
methodology for the supervisory control of flexible manufacturing
workcells”, Journal of Manufacturing Systems, Vol. 16, No. 2, pp. 91-
101, 1997.
[6] A. Ramirez-Serrano, S. C. Zhu, and B. Benhabib, “Moore automata
for the supervisory control of robotic manufacturing workcells”,
Autonomous Robots, Vol. 9, pp. 59-69, 2000.
[7] A. Ramirez-Serrano, S. C. Zhu, S. K. H. Chan, S. S. W. Chan, M.
Ficocelli and B. Benhabib, “A hybrid PC/PLC architecture for
manufacturing-system control-theory and implementation”, Journal of
Intelligent Manufacturing, 13, 261-281, 2002.
[8] Max H. De Queiroz and Jose E. R. Cury, “Synthesis and
implementation of local modular supervisory control for a
manufacturing cell”, Proceedings of the 6th International Workshop
on Discrete Event Systems, Zaragosa, Spain, pp. 377-382, 2002.
[9] A.D. Vieira, Jose E. R. Cury, and Max H. De Queiroz “A model for
implementation of supervisory control of a discrete event systems”,
Proceedings of IEEE Conference on Emerging Technologies and
Factory Automation, ETFA’2006, pp. 225-232, 2006.
[10] D. Gouyon, J.F. Petin, and A. Gouin, “Pragmatic approach for
modular synthesis and implementation,” International Journal of
Production Research, Vol. 42, No. 14, pp. 2839-2858, 2004.
[11] J. Liu and H. Darabi, “Ladder logic implementation of Ramadge-
Wonham supervisory controller”, Proceedings of the 6th International
Workshop on Discrete Event Systems, Zaragosa, Spain, , pp. 383-389,
2002.
[12] M. Moniruzzaman and P. Gohari, “Implementing supervisory control
maps with PLC,” Proceedings of the 2007 America Control
Conference, Newyork City, USA, pp. 3594-3599, 2007.
[13] S. Manesis and K. Akantziotis, “Automated synthesis of ladder
automation circuits based on state-diagrams”, Advances in
Engineering Software Vol. 36, pp. 225-233, 2005.
[14] M.Uzam, G. Gelen, R. Dalc, “A new approach for the ladder logic
implementation of Ramadge-Wonham supervisors”, Proceedings of
the 22nd International Symposium on Information, Communication
and Automation Technologies, Sarajevo, Bosnia and Herzegovina,
October 29-31, 2009.
[15] M. Fabian and A. Hellegren, “PLC-based implementation of
supervisory control for discrete event systems,” Proceedings of the
37th IEEE Conference on Decision and Control, Tampa, Florida, USA,
pp. 3305-3310, 1998.
[16] .T. Hasdemir, S. Kurtulan, and L. Gören, “An implementation
methodology for supervisory control theory,” International Journal of
Advanced Manufacturing Technology, Vol. 36, pp. 373-385, 2008.
[17] TCT. A software tool supporting supervisory control theory. Systems
Control Group, ECE Dept., University of Toronto, Posted at URL:
www.control.utoronto.ca/DES (2009).
[18] IEC 61131-3 (2003) Programmable controllers – part 3: programming
languages.
1993
