Bryan L. Programmable controllers. Theory and implementation
Подождите немного. Документ загружается.
389
CHAPTER
10
The IEC 1131 Standard and
Programming Language
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
SECTION
3
PLC
Programming
occurs (i.e., the limit switch LS_Reach triggers). After the PLC finishes action
2, it will wait for transition 2 (IF Temp_1≥100) to occur and then move to
step 3.
As mentioned earlier, the sequential function chart language has its origin in
the French standard Grafcet, a flowchart-like programming language. The
Grafcet graphic language also uses steps, transitions, and actions, which
operate in the same manner as in SFC. In Grafcet, when a step is active, the
processor scans the I/O logic and program pertinent to the step’s action, as
well as the logic for the transition immediately after it (i.e., the transition
that deactivates the step and action).
Like Grafcet, SFC is similar to a flowchart in the way control is passed
from
one step to another (see Figure 10-16). Also, like in Grafcet, SFC can
be programmed to directly relate to timing or event diagrams. Figure 10-17
shows a comparison of a timing diagram and its related Grafcet and SFC
programs. As shown in the timing diagram (see Figure 10-17a), if the
condition Part_Present_LS is satisfied (the limit switch closes), the
Advance_Solenoid output will turn ON. Once the Part_In_Position_LS vari-
able is ON, the Clamp_Solenoid output will turn ON. Then, when the
At_Depth_LS condition becomes TRUE, the Drill_Motor output will turn
ON for 10 seconds. Note that the Clamp_Solenoid output is also activated
during the Drill_Motor action. Once the time expires, the timing diagram
indicates that the Clamp_Solenoid and
Drill_Motor outputs will both turn
OFF and stay OFF, while the Return_Solenoid output turns ON. No further
Figure 10-16. Comparison of (a) an SFC diagram and (b) a flowchart.
1
2
3
1
2
3
Trans_1
Trans_2
Trans_3
Action_2
Action_3
Start
Trans_1
?
Trans_2
?
Step 2 Action
Step 3 Action
ON
ON
OFF
OFF
(a) SFC
(b) Flowchart
390
SECTION
3
PLC
Programming
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
CHAPTER
10
The IEC 1131 Standard and
Programming Language
action will occur until the At_Top_LS command is satisfied, at which time,
the process will stop and the Return_Solenoid output will reset for another
sequence. Figures 10-17b and 10-17c illustrate the timing diagram as
implemented in Grafcet and SFC, respectively. Both of these programming
languages graphically represent the timing diagram implementation using
Figure 10-17. Comparison of (a) a timing diagram with its associated (b) Grafcet
and (c) SFC programs.
1
2
3
Part_Present_LS
Part_ In_Position_LS
At_Depth_LS
4
5
TMR/Step_4/10 Sec
At_Top_LS
Return_Solenoid
Wait
Advance_Solenoid
1
2
3
Part_Present_LS
Part_ In_Position_LS
At_Depth_LS
4
5
TMR/Step_4/10 Sec
At_Top_LS
Return_Solenoid:=True
Clamp_Solenoid
Drill_Motor
Clamp_Solenoid:=True
Drill_Motor:=True
Advance_Solenoid:=True
Clamp_Solenoid Clamp_Solenoid:=True
Advance_Solenoid
Clamp_Solenoid
Drill_Motor
Return_Solenoid
Outputs Activation
Part_Present_LS
Part_In_Position_LS
At_Depth_LS
Timer_10_Sec_Up
At_Top_LS
(a) Timing diagram
(b) Grafcet (c) IEC 1131-3 SFC
Transitions
(a) Timing diagram
(b) Grafcet
(c) IEC 1131-3 SFC
391
CHAPTER
10
The IEC 1131 Standard and
Programming Language
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
SECTION
3
PLC
Programming
steps, actions, and transitions. The actions represent the activation of the
solenoid and drill motor, while the transitions represent the limit switch inputs
and timer status.
The major difference between Grafcet and SFC is that Grafcet employs only
written action statements, such as Open_Variable (e.g., Open_Valve) to
implement its action blocks and turn devices ON and OFF. SFC, on the
other hand, implements actions in a number of ways using LD, IL, ST, and
FBD or a combination of these languages, including custom function blocks.
For example, in action 2 of the Grafcet program in Figure 10-17b, the
statement Advance_Solenoid indicates the turning ON of the field device
associated with the output variable assigned to Advance_Solenoid. In other
words, if an output variable is stated in a Grafcet action, it will become
TRUE or ON. In the SFC-equivalent program in Figure 10-17c, the step 2
instruction indicates that the Advance_Solenoid will be equal to TRUE
(ON). Thus, SFC does not actually contain a statement of the output
variable, but rather an instruction that turns the device ON or OFF (TRUE
or FALSE) during that action.
Sequential function charts can be thought of as building-block objects used
to create the “total” control program, or the big picture, while the other
languages are used to implement detailed programming within the SFC. In
fact, SFCs can have what are known in Grafcet terms as macrosteps, which
allow one master sequential function chart to have other sequential function
charts as its actions (see Figure 10-18). These smaller, embedded sequential
function charts, which have their own steps, transitions, and actions, are
similar to subroutines in a program.
Figure 10-18. Macrostep within an SFC program.
Macrostep
Macrostep SFC
Program
Main
SFC
Program
392
SECTION
3
PLC
Programming
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
CHAPTER
10
The IEC 1131 Standard and
Programming Language
PROGRAMMING LANGUAGE NOTATION
One of the greatest advantages of sequential function charts is that they are
easier to troubleshoot than standard ladder diagram programs. For example,
in the sequential function chart shown earlier in Figure 10-17c, if the action
Clamp_Solenoid (solenoid ON) at step 3 does not make the transition to step
4, it is easy to recognize that a problem occurred at the transition after step 3,
which corresponds to the activation of the At_Depth_LS transition. Thus, an
SFC pinpoints the step or transition where a fault occurs.
As we have noted, sequential function charts can provide the infrastructure
for a control program, which is then built using one or more of the four IEC
1131-3 programming languages. In the next section, we will further explain
how SFCs can be used implement a control program. However, let’s first
review the similarities between programming notations in the ladder dia-
gram (LD), function block diagram (FBD), structured text (ST), and instruction
list (IL) languages.
Figure 10-19 shows a simple ladder diagram and its FBD, ST, and IL
language equivalents. Note that the ST language (see Figure 10-19c) uses two
operators, AND and &, to denote the AND function. The := symbol is used in
an ST program to assign an output variable (e.g., Valve_3) to a logic
expression. In instruction list (see Figure 10-19d), the first instruction
(instruction LD) loads the status of variable Limit_S_1 to the accumulator
register, which IL calls the result register. The second instruction (instruc-
tion AND) ANDs the status of Limit_S_1 with the variable Start_Cycle and
stores the outcome back in the result register. The third instruction (instruc-
tion ST) stores the contents of the result register as the output variable,
Valve_3. This process is similar to Boolean programming language.
As demonstrated, the instructions used to implement control sequences in
each programming language are very similar in their construction, as well as
their visual representation. Depending on the PLC application, an SFC may
use one or more of these languages to program instructions inside its actions.
To differentiate between languages, some software manufacturers include
starting and ending commands that define the language being used. Other
manufacturers allow the mixing of languages without any differentiation
between them. Figure 10-20 illustrates a group of instructions that have
been labeled with a differentiation mnemonic. The term #Language=name
signals the beginning of a language, and #ENDlanguagename signals the
end of it.
393
CHAPTER
10
The IEC 1131 Standard and
Programming Language
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
SECTION
3
PLC
Programming
Figure 10-19. Implementation of a simple program in (a) ladder diagram, (b) function
block diagram, (c) structured text, and (d) instruction list.
Bool_Var (Boolean variable) Inputs: Limit_S_1 for Limit Switch 1
Start_Cycle for Start Cycle PB
Bool_Var (Boolean variable) Outputs: Valve_3 for Solenoid Valve #3
(c) Structured text (ST)
Valve_3:=Limit_S_1
AND
Start_Cycle
or
Valve_3:=Limit_S_1
&
Start_Cycle
Input
Logic ExpressionOutput
Limit_S_1 Start_Cycle Valve_3
(a) Ladder diagram (LD)
Inputs Output
Limit_S_1 Valve_3
Start_Cycle
(b) Function block diagram (FBD)
&
AND
Inputs Output
Function
Block
(d) Instruction list (IL)
LD
AND
ST
Limit_S_1
Start_Cycle
Valve_3
(*Load the status of Limit_S_1*)—variable to the result register
(*AND it with Start_Cycle*)—variable ANDed with result register
(*Result register is stored as the Boolean variable Valve_3*)
Name Variable Description
Control LogicInputs and Outputs
(a) Ladder diagram (LD)
(b) Function block diagram (FBD)
(c) Structured text (ST)
(d) Instruction list (IL)
394
SECTION
3
PLC
Programming
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
CHAPTER
10
The IEC 1131 Standard and
Programming Language
EXAMPLE 10-3
In PLC applications, many limit switches exhibit a “bouncing” behav-
ior (see Figure 10-21), meaning that the switch opens and closes
several times before finally turning ON or OFF. Develop an encapsu-
lated custom function block (see Figure 10-22), which will provide 50
msec debouncing capabilities, that can be stored in a library and
used to program all bouncing input limit switches. Note that
debouncing must be performed for both the OFF-to-ON and the ON-
to-OFF transitions.
S
OLUTION
Figure 10-23 illustrates the timing diagram of the limit switch input. It
shows that a 50 msec delay (shown in blue) should exist in the OFF-
to-ON and ON-to-OFF transitions to filter any bouncing signals. Timers
can be used to implement both delays.
#Language=LD
#ENDlanguageLD
#ENDlanguageST
#Language=ST
If Motor Then Light_Out
Else DL_Motor_Off
#Language=FBD
#ENDlanguageFBD
&
OR
a
b
LS
#ENDlanguageIL
#Language=IL
LD LS1
AND LS2
STR Motor
Figure 10-20. Languages within an SFC differentiated by beginning and ending
language labels.
395
CHAPTER
10
The IEC 1131 Standard and
Programming Language
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
SECTION
3
PLC
Programming
Figure 10-23. Timing diagram for a bouncing input signal.
Figure 10-21. Bouncing behavior in a limit switch.
Figure 10-22. Rough diagram of an encapsulated debouncing function block.
Figure 10-24 illustrates the implementation of a debouncing circuit
using ladder diagrams and an ON-delay energize timer. Figure 10-25
shows the corresponding timing diagram. Note that the output of the
latch/unlatch output (102) is the actual input, in this case the limit
L1 L2
LS
LS_Before
DB OUT
Debounce FBD
Valid_LS
Input Wiring PLC Program
OFF ON ON OFF
0
1
OFF
ON
Bouncing may cause a faulty reading
0
1
LS_Before
0
1
Valid_LS
50 msec
50 msec
DT: Delay Time
Delays to prevent false triggering of signal
396
SECTION
3
PLC
Programming
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
CHAPTER
10
The IEC 1131 Standard and
Programming Language
LS_Before TON 100
AR 4000
PR 4100
LS_Before TON 101
AR 4001
PR 4100
100
Valid_LS
L102
L
101
Valid_LS
U102
U
LS
Delay_Time
Constant
Valid_LS
Debounce FBD
LS_Before
Preset
Reg
4100
ACC
Reg
4000,
4001
OUT
102
(Latch/Unlatch)
LS_Before: The input to
the block from the limit
switch before debouncing.
Preset Reg 4100: The reg-
ister that holds the delay
constant defined by the
user’s input named De-
lay_Time, in this case 50
msec.
Inputs
OUT 102: The FBD output
of the limit switch after the
debounce delay.
ACC Reg: Registers 4000
and 4001, which hold the
value of the timer’s accu-
mulated registers.
Outputs
Figure 10-24. Debouncing function block programmed using ladder diagram.
Figure 10-25. Timing diagram for the ladder circuit in Figure 10-24.
switch signal after passing through the debouncing circuit. Figure 10-
26 illustrates the same type of debouncing filter implementation using
FBD. Note that the output of the set/reset (S/R), or bistable, block will
DT
DT
DT
DT
50 msec
50 msec
50 msec
1
0
LS_Before
1
0
Set
1
0
LS_Before
1
0
Reset
1
0
Valid_LS
397
CHAPTER
10
The IEC 1131 Standard and
Programming Language
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
SECTION
3
PLC
Programming
also be the debounced limit switch input (Valid_LS). The variable
T_Delay will be an integer that is a preset time value of 50 msec. The
input signals LS_Before (limit switch before debouncing) and
Valid_LS (limit switch after debouncing) are both Bool (TRUE/FALSE)
variables. Once created, the function block diagram can be encapsu-
lated as a custom block as shown in Figure 10-27a. It can then be used
with any input that requires a 50 msec debounce filter (see Figure 10-
27b). The encapsulated block can satisfy any debounce requirement
as long as the T_Delay variable is specified accordingly.
Figure 10-26. Debouncing circuit programmed using FBD.
Figure 10-27. (a) FBD as an encapsulated custom block and (b) a custom block used
to debounce three limit switch signals.
LS
TON_1
IN OUT
PR AR
TON_2
IN OUT
PR AR
S/R
S OUT
R
LS_Before
T_Delay
Valid_LS
50 msec
constant
Debouce FBD
LS_Before
Valid_LSLS_Before
50 msec
constant
OUT
T_Delay
Debounce
Block
IN
Valid_LS1
Valid_LS2
Valid_LS3
LS1_Before
50 msec
constant
OUT
T_Delay
IN
LS2_Before
LS3_Before
OUT
T_Delay
IN OUT
T_Delay
(a)
(b)
Three limit switches—
LS1, LS2, and LS3—
defined as: LS1_Before,
LS2_Before, and LS3_Before.
398
SECTION
3
PLC
Programming
Industrial Text & Video Company 1-800-752-8398
www.industrialtext.com
CHAPTER
10
The IEC 1131 Standard and
Programming Language
SFC FORMAT
Sequential function charts represent the order of events in a sequential
process. An SFC divides a process into many steps, which are represented by
various graphic components (see Figure 10-28). All of these components are
used to form one or more charts that comprise the complete control program.
IN
OUT
15
16
17
15
16
17
10
11
12
10
11
12
30
31
32
30
31
Y12
X10
1
2
3
4
1
2
3
4
CHART 1 CHART 2 CHART 3
Figure 10-29, for example, illustrates a small control program composed of
three SFCs, each with its own independent initial step. By having indepen-
dent steps, the control program starts scanning all of these charts when it
first begins program execution, providing a parallel beginning. Chart 3
Figure 10-28. Graphic symbols used in SFCs.
Figure 10-29. Three SFCs representing a control process.
Initial Step
Step
Transition
Jump to a Step
Macrostep
Beginning Macrostep
Ending Macrostep
IN
OUT