Chapter 7 - AutomationDirect

Chapter 7 - AutomationDirect
RLLPLUS STAGE
PROGRAMMING
CHAPTER
7
In This Chapter...
Introduction to Stage Programming . . . . . . . . . . . . . . . . . . . . . . . .7–2
Learning to Draw State Transition Diagrams . . . . . . . . . . . . . . . . . .7–3
Using the Stage Jump Instruction for State Transitions . . . . . . . . . . .7–7
Stage Program Example: Toggle On/Off Lamp Controller . . . . . . . .7–8
Four Steps to Writing a Stage Program . . . . . . . . . . . . . . . . . . . . . .7–9
Stage Program Example: A Garage Door Opener . . . . . . . . . . . . . .7–10
Stage Program Design Considerations . . . . . . . . . . . . . . . . . . . . . .7–15
Parallel Processing Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7–19
Managing Large Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7–21
RLLPLUS (Stage) Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7–23
Questions and Answers about Stage Programming . . . . . . . . . . . .7–29
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
Introduction to Stage Programming
þ 230
þ 240
þ 250-1
þ 260
7–2
Stage Programming (available in all DL205 CPUs) provides a way to organize and program
complex applications with relative ease, when compared to purely relay ladder logic (RLL)
solutions. Stage programming does not replace or negate the use of traditional boolean ladder
programming. This is why Stage Programming is also called RLLPLUS. You will not have to
discard any training or experience you already have. Stage programming simply allows you to
divide and organize a RLL program into groups of ladder instructions called stages. This
allows quicker and more intuitive ladder program development than traditional RLL alone
provides.
Overcoming “Stage Fright”
Many PLC programmers in the industry have
become comfortable using RLL for every PLC
program they write... but often remain skeptical
or even fearful of learning new techniques such
as stage programming. While RLL is great at
solving boolean logic relationships, it has
disadvantages as well:
• Large programs can become almost unmanageable,
because of a lack of structure.
X0
X4
C1
C0
RST
Y0
SET
STAGE!
X3
• In RLL, latches must be tediously created from selflatching relays.
Y2
OUT
• When a process gets stuck, it is difficult to find the
rung where the error occurred.
• Programs become difficult to modify later, because
they do not intuitively resemble the application
problem they are solving.
It’s easy to see that these inefficiencies consume a lot of additional time, and time is money.
Stage programming overcomes these obstacles! We believe a few moments of studying the stage
concept is one of the greatest investments in programming speed and efficiency a PLC
programmer can make!
So, we encourage you to study stage programming and add it to your “toolbox” of
programming techniques. This chapter is designed as a self-paced tutorial on stage
programming. For best results:
• Start at the beginning and do not skip over any sections.
• Study each stage programing concept by working through each example. The examples build
progressively on each other.
• Read the Stage Questions and Answers at the end of the chapter for a quick review.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Learning to Draw State Transition Diagrams
Introduction to Process States
Ladder
Program
Inputs
Outputs
Those familiar with ladder program execution know the
CPU must scan the ladder program repeatedly, over and
over. Its three basic steps are:
PLC Scan
1. Read the inputs
1) Read
Execute
Write
2. Execute the ladder program
2) Read
Execute
Write
3. Write the outputs
3) Read
(Etc.....)
The benefit is that a change at the inputs can affect the
outputs in just a few milliseconds.
Most manufacturing processes consist of a series of activities or conditions, each lasting for
several seconds, minutes, or even hours. We might call these “process states”, which are either
active or inactive at any particular time. A challenge for RLL programs is that a particular
input event may last for a brief instant. We typically create latching relays in RLL to preserve
the input event in order to maintain a process state for the required duration. We can
organize and divide ladder logic into sections called “stages”, representing process states. But
before we describe stages in detail, we will reveal the secret to understanding stage
programming: state transition diagrams.
The Need for State Diagrams
Sometimes we need to forget about the scan nature of PLCs, and focus our thinking toward
the states of the process we need to identify. Clear thinking and concise analysis of an
application gives us the best chance at writing efficient, bug-free programs. State diagrams are
tools to help us draw a picture of our process! You will discover that if we can get the picture
right, our program will also be right!
Inputs
A 2–State Process
ON
Outputs
X0
Motor
Ladder
Consider the simple process shown to the right, which controls
Y0
OFF
Program
X1
an industrial motor. We will use a green momentary SPST
pushbutton to turn the motor on, and a red one to turn it off.
Transition condition
The machine operator will press the appropriate pushbutton for
X0
a second or so. The two states of our process are ON and OFF. State
OFF
ON
The next step is to draw a state transition diagram, as shown to
X1
the right. It shows the two states OFF and ON, with two
transition lines in-between. When the event X0 is true, we
Output equation: Y0 = On
transition from OFF to ON. When X1 is true, we transition
from ON to OFF.
If you’re following along, you are very close to grasping the concept and the problem-solving
power of state transition diagrams. The output of our controller is Y0, which is true any time
we are in the ON state. In a boolean sense, Y0=ON state.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–3
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–4
The state transition diagram to the right is a picture
of the solution we need to create. The beauty of it is
this: it expresses the problem independently of the
programming language we may use to realize it. In
other words, by drawing the diagram we have already
solved the control problem!
First, we’ll translate the state diagram to traditional
RLL. Then we’ll show how easy it is to translate the
diagram into a stage programming solution.
RLL Equivalent
The RLL solution is shown to the right. It consists of
a self-latching motor output coil, Y0. When the On
pushbutton (X0) is pressed, output coil Y0 turns on
and the Y0 contact on the second row latches itself
on. So, X0 sets the latch Y0 on, and it remains on
after the X0 contact opens.
When the Off pushbutton (X1) is pressed, it opens
the normally-closed X1 contact, which resets the
latch. Motor output Y0 turns off.
X0
OFF
ON
X1
Output equation Y0 = ON
Set
X0
Reset
X1
Output
Y0
OUT
Latch
Y0
Stage Equivalent
The stage program solution is shown to the right.
SG
OFF State
S0
The two inline stage boxes S0 and S1 correspond to
the two states OFF and ON. The ladder rung(s)
Transition
below each stage box belong to each respective stage.
S1
X0
This means that the PLC only has to scan those rungs
JMP
when the corresponding stage is active!
For now, let’s assume we begin in the OFF State, so
SG
ON State
stage S0 is active. When the On pushbutton (X0) is
S1
Output
pressed, a stage transition occurs. The JMP S1
SP1 Always On
Y0
instruction executes, which simply turns off the Stage
OUT
bit S0 and turns on Stage bit S1. So on the next PLC
scan, the CPU will not execute Stage S0, but will
Transition
execute stage S1!
S0
X1
In the On State (Stage S1), we want the motor to
JMP
always be on. The special relay contact SP1 is defined
as always on, so Y0 turns the motor on.
When the Off pushbutton (X1) is pressed, a transition back to the Off State occurs. The JMP
S0 instruction executes, which simply turns off the Stage bit S1 and turns on Stage bit S0. On
the next PLC scan, the CPU will not execute Stage S1, so the motor output Y0 will turn off.
The Off state (Stage 0) will be ready for the next cycle.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Let’s Compare
Right now, you may be thinking “I don’t see the big advantage to Stage Programming... in
fact, the stage program is longer than the plain RLL program”. Well, now is the time to
exercise a bit of faith. As control problems grow in complexity, stage programming quickly
out-performs RLL in simplicity, program size, etc.
For example, consider the diagram below. Notice how easy
it is to correlate the OFF and ON states of the state
SG
OFF State
S0
transition diagram below to the stage program at the right.
S1
X0
Now, we challenge anyone to
JMP
easily identify the same states
in the RLL program on the
SG
ON State
S1
previous page!
SP1
Initial Stages
Y0
OUT
X0
At powerup and Program-toOFF
ON
Run Mode transitions, the
X1
PLC always begins with all
normal stages (SG) off. So, the stage programs shown so far
have actually had no way to get started (because rungs are
not scanned unless their stage is active).
Assume that we want to always begin in the Off state
(motor off ), which is how the RLL program works. The
Initial Stage (ISG) is defined to be active at powerup. In
the modified program to the right, we have changed stage
S0 to the ISG type. This ensures the PLC will scan
contact X0 after powerup, because Stage S0 is active.
After powerup, an Initial Stage (ISG) works just like any
other stage!
We can change both programs so that the motor is ON at
powerup. In the RLL below, we must add a first scan relay
SP0, latching Y0 on. In the stage example to the right, we
simply make Stage S1 an initial stage (ISG) instead of S0.
S0
X1
JMP
Powerup in OFF State
ISG
S0
Initial Stage
S1
X0
JMP
SG
S1
SP1
Y0
OUT
S0
X1
JMP
Powerup in ON State
SG
S0
S1
X0
JMP
Powerup in ON State
X0
Y0
SP0
X1
Y0
OUT
ISG
S1
Initial Stage
SP1
First Scan
X1
Y0
OUT
S0
JMP
NOTE: If the ISG is within the retentive range for stages, the ISG will remain in the state it was in before
power down and will NOT turn itself on during the first scan.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–5
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–6
We can mark our desired powerup state as shown to
the right, which helps us remember to use the
appropriate Initial Stages when creating a stage
program. It is permissible to have as many initial
stages as the process requires.
Powerup
X0
OFF
ON
X1
What Stage Bits Do
You may recall that a stage is a section of ladder program which is either active or inactive at a
given moment. All stage bits (S0 to Sxxx) reside in the PLC’s image register as individual
status bits. Each stage bit is either a boolean 0 or 1 at any time.
Program execution always reads ladder rungs from top to bottom, and from left to right. The
drawing below shows the effect of stage bit status. The ladder rungs below the stage
instruction continuing until the next stage instruction or the end of program belong to stage
0. Its equivalent operation is shown on the right. When S0 is true, the two rungs have power
flow.
• If Stage bit S0 = 0, its ladder rungs are not scanned (executed).
• If Stage bit S0 = 1, its ladder rungs are scanned (executed).
Actual Program Appearance
SG
S0
Functionally Equivalent Ladder
S0
(includes all rungs in stage)
Stage Instruction Characteristics
The inline stage boxes on the left power rail divide the ladder
program rungs into stages. Some stage rules are:
• Execution – Only logic in active stages are executed on any
scan.
• Transitions – Stage transition instructions take effect on the
next occurrence of the stages involved.
• Octal numbering – Stages are numbered in octal, like I/O
points, etc. So “S8” is not valid.
• Total Stages – The maximum number of stages is CPUdependent.
SG
S0
SG
S1
SG
S2
• No duplicates – Each stage number is unique and can be used
just once.
• Any order – You can skip numbers and sequence the stage
numbers in any order.
• Last Stage – The last stage in the ladder program includes all
rungs from its stage box until the end coil.
DL205 User Manual, 4th Edition, Rev. B
END
Chapter 7: RLLPLUS Stage Programming
Using the Stage Jump Instruction for State Transitions
Stage Jump, Set, and Reset Instructions
The Stage JMP instruction we have used deactivates the stage in which the instruction occurs,
while activating the stage in the JMP instruction. Refer to the state transition shown below.
When contact X0 energizes, the state transition from S0 to S1 occurs. The two stage examples
shown below are equivalent. So, the Stage Jump instruction is equal to a Stage Reset of the
current stage, plus a Stage Set instruction for the stage to which we want to transition.
X0
S0
SG
S0
X0
S1
S1
SG
S0
Equivalent
S0
X0
JMP
RST
S1
SET
Please Read Carefully – The jump instruction is easily misunderstood. The “jump” does not
occur immediately like a GOTO or GOSUB program control instruction when executed.
Here’s how it works:
• The jump instruction resets the stage bit of the stage in which it occurs. All rungs in the stage still
finish executing during the current scan, even if there are other rungs in the stage below the jump
instruction!
• The reset will be in effect on the following scan, so the stage that executed the jump instruction
previously will be inactive and bypassed.
• The stage bit of the stage named in the Jump instruction will be set immediately, so the stage will be
executed on its next occurrence. In the left program shown below, stage S1 executes during the same
scan as the JMP S1 occurs in S0. In the example on the right, Stage S1 executes on the next scan
after the JMP S1 executes, because stage S1 is located above stage S0.
SG
S0
Executes on next
scan after Jmp
SG
S1
X0
S1
S1
JMP
Executes on same
scan as Jmp
SG
S1
S1
Y0
Y0
OUT
SG
S0
X0
S1
JMP
OUT
Note: Assume we start with Stage 0 active and stage 1 inactive for both examples.
NOTE: Assume we start with Stage 0 active and Stage 1 inactive for both examples.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–7
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
Stage Program Example: Toggle On/Off Lamp Controller
7–8
A 4–State Process
Inputs
Outputs
In the process shown to the right, we use an ordinary
momentary pushbutton to control a light bulb. The
Toggle
Ladder Y0
X0
ladder program will latch the switch input, so that we
Program
will push and release to turn on the light, push and
release again to turn it off (sometimes called toggle
function). Sure, we could buy a mechanical switch with
Powerup
the alternate on/off action built in... However, this
X0
example is educational and also fun!
OFF
ON
Next we draw the state transition diagram. A typical first
X0
approach is to use X0 for both transitions (like the
Output equation: Y0 = ON
example shown to the right). However, this is incorrect
(please keep reading).
Note that this example differs from the motor example, because now we have only one
pushbutton. When we press the pushbutton, both transition conditions are met. We would
transition around the state diagram at top speed. If implemented in Stage, this solution would
flash the light on or off each scan (obviously undesirable)!
The solution is to make the push and the release of the pushbutton separate events. Refer to
the new state transition diagram below. At powerup we enter the OFF state. When switch X0
is pressed, we enter the Press-ON state. When it is released, we enter the ON state. Note that
X0 with the bar above it denotes X0 NOT.
Powerup
X0
Push–ON
X0
OFF
ISG
S0
ON
OFF State
S1
X0
JMP
X0
Push–OFF
X0
SG
S1
Output equation: Y0 = ON
When in the ON state, another push and release cycle
similarly takes us back to the OFF state. Now we have
two unique states (OFF and ON) used when the
pushbutton is released, which is what was required to
solve the control problem.
The equivalent stage program is shown to the right. The
desired powerup state is OFF, so we make S0 an initial
stage (ISG). In the ON state, we add special relay
contact SP1, which is always on.
Note that even as our programs grow more complex, it
is still easy to correlate the state transition diagram with
the stage program!
DL205 User Manual, 4th Edition, Rev. B
Push–On State
S2
X0
JMP
SG
S2
ON State
Output
SP1
Y0
OUT
S3
X0
JMP
SG
S3
Push–Off State
X0
S0
JMP
Chapter 7: RLLPLUS Stage Programming
Four Steps to Writing a Stage Program
By now, you’ve probably noticed that we follow the same steps to solve each example
problem. The steps will probably come to you automatically if you work through all the
examples in this chapter. It’s helpful to have a checklist to guide us through the problem
solving. The following steps summarize the stage program design procedure:
1. Write a Word Description of the application.
Describe all functions of the process in your own words. Start by listing what happens first,
then next, etc. If you find there are too many things happening at once, try dividing the
problem into more than one process. Remember, you can still have the processes
communicate with each other to coordinate their overall activity.
2. Draw the Block Diagram.
Inputs represent all the information the process needs for decisions, and outputs connect to
all devices controlled by the process.
• Make lists of inputs and outputs for the process.
• Assign I/O point numbers (X and Y) to physical inputs and outputs.
3. Draw the State Transition Diagram.
The state transition diagram describes the central function of the block diagram, reading
inputs and generating outputs.
• Identify and name the states of the process.
• Identify the event(s) required for each transition between states.
• Ensure the process has a way to re-start itself, or is cyclical.
• Choose the powerup state for your process.
• Write the output equations.
4. Write the Stage Program.
Translate the state transition diagram into a stage program.
• Make each state a stage. Remember to number stages in octal. Up to 256 total stages are available in
the DL230 CPU. Up to 512 total stages are available in the DL240 CPU. Up to 1024 total stages
are available in the DL250–1 and DL260 CPUs.
• Put transition logic inside the stage which originates each transition (the stage each arrow points
away from).
• Use an initial stage (ISG) for any states that must be active at powerup.
• Place the outputs or actions in the appropriate stages.
You will notice that Steps 1 through 3 prepare us to write the stage program in Step 4.
However, the program virtually writes itself because of the preparation beforehand. Soon you
will be able to start with a word description of an application and create a stage program in
one easy session!
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–9
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
Stage Program Example: A Garage Door Opener
Garage Door Opener Example
In this next stage programming example we will
create a garage door opener controller. Hopefully
most readers are familiar with this application, and
we can have fun besides!
The first step we must take is to describe how the
door opener works. We will start by achieving the
basic operation, waiting to add extra features later
(stage programs are very easy to modify).
Our garage door controller has a motor which raises
or lowers the door on command. The garage owner
pushes and releases a momentary pushbutton once to
raise the door. After the door is up, another pushrelease cycle will lower the door.
In order to identify the inputs and outputs of the
system, it’s sometimes helpful to sketch its main
components, as shown in the door side view to the
right. The door has an up limit and a down limit
switch. Each limit switch closes only when the door
has reached the end of travel in the corresponding
direction. In the middle of travel, neither limit switch
is closed.
The motor has two command inputs: raise and lower.
When neither input is active, the motor is stopped.
The door command is a simple pushbutton. Whether
wall-mounted as shown, or a radio-remote control, all
door control commands logically OR together as one
pair of switch contacts.
Up limit switch
Raise
Lower
Motor
Door
Command
Down limit switch
Draw the Block Diagram
7–10
The block diagram of the controller is shown to the
right. Input X0 is from the pushbutton door control.
Input X1 energizes when the door reaches the full up
position. Input X2 energizes when the door reaches
the full down position. When the door is positioned
between fully up or down, both limit switches are
open.
The controller has two outputs to drive the motor.
Y1 is the up (raise the door) command, and Y2 is the
down (lower the door) command.
DL205 User Manual, 4th Edition, Rev. B
Inputs
Toggle
Up limit
Down limit
Outputs
X0
X1
X2
To motor:
Ladder
Program Y1
Raise
Y2
Lower
Chapter 7: RLLPLUS Stage Programming
Draw the State Diagram
Now we are ready to draw the state transition diagram. Like the previous light bulb controller
example, this application also has only one switch for the command input. Refer to the figure
below.
• When the door is down (DOWN state), nothing happens until X0 energizes. Its push and release
brings us to the RAISE state, where output Y1 turns on and causes the motor to raise the door.
• We transition to the UP state when the up limit switch (X1) energizes, and turns off the motor.
• Then nothing happens until another X0 press-release cycle occurs. That takes us to the LOWER
state, turning on output Y2 to command the motor to lower the door. We transition back to the
DOWN state when the down limit switch (X2) energizes.
Powerup
X0
Push–UP
X0
RAISE
X1
ISG
S0
DOWN
LOWER
Push–DOWN
X0
JMP
SG
S1
X0
Output equations: Y1 = Raise
S1
X0
UP
X2
DOWN State
Push–UP State
S2
X0
JMP
Y2 = Lower
The equivalent stage program is shown to the right. For now, we
will assume the door is down at powerup, so the desired powerup
state is DOWN. We make S0 an initial stage (ISG). Stage S0
remains active until the door control pushbutton activates. Then
we transition (JMP) to Push-UP stage, S1.
A push-release cycle of the pushbutton takes us through stage S1
to the RAISE stage, S2. We use the always-on contact SP1 to
energize the motor’s raise command, Y1. When the door reaches
the fully-raised position, the up limit switch X1 activates. This
takes us to the UP Stage S3, where we wait until another door
control command occurs.
In the UP Stage S3, a push-release cycle of the pushbutton will
take us to the LOWER Stage S5, where we activate Y2 to
command the motor to lower the door. This continues until the
door reaches the down limit switch, X2. When X2 closes, we
transition from Stage S5 to the DOWN stage S0, where we began.
SG
S2
RAISE State
SP1
Y1
OUT
S3
X1
JMP
SG
S3
UP State
S4
X0
JMP
SG
S4
Push–DOWN State
S5
X0
JMP
SG
S5
LOWER State
SP1
X2
NOTE: The only thing special about an initial stage (ISG) is that it is
automatically active at powerup. Afterwards, it is just like any other.
DL205 User Manual, 4th Edition, Rev. B
Y2
OUT
S0
JMP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–11
Chapter 7: RLLPLUS Stage Programming
Add Safety Light Feature
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
Next we will add a safety light feature to the door
opener system. It’s best to get the main function
working first as we have done, then adding the
secondary features.
The safety light is standard on many commerciallyavailable garage door openers. It is shown to the
right, mounted on the motor housing. The light
turns on upon any door activity, remaining on for
approximately 3 minutes afterwards.
This part of the exercise will demonstrate the use of
parallel states in our state diagram. Instead of using
the JMP instruction, we will use the set and reset
commands.
Modify the Block Diagram and State Diagram
7–12
Safety light
Inputs
Outputs
To control the light bulb, we add an output to our
Toggle
controller block diagram, shown to the right, Y3 is the
X0
Y1
Raise
light control output.
Up limit
In the diagram below, we add an additional state
Y2
X1
Lower
called “LIGHT”. Whenever the garage owner presses
the door control switch and releases, the RAISE or
LOWER state is active and the LIGHT state is
Down limit
X2
Y3
simultaneously active. The line to the Light state is
Light
dashed, because it is not the primary path.
We can think of the Light state as a parallel process to the raise and lower state. The paths to
the Light state are not a transition (Stage JMP), but a State Set command. In the logic of the
Light stage, we will place a three-minute timer. When it expires, timer bit T0 turns on and
resets the Light stage. The path out of the Light stage goes nowhere, indicating the Light stage
becomes inactive, and the light goes out!
Output equations: Y1 = RAISE
Y2 = LOWER
Y3 = LIGHT
RAISE
X1
X0
X0
Push–UP
X0
DOWN
LIGHT
UP
T0
X0
X2
LOWER
Push–DOWN
X0
DL205 User Manual, 4th Edition, Rev. B
X0
Chapter 7: RLLPLUS Stage Programming
Using a Timer Inside a Stage
The finished modified program is shown to the right. The
shaded areas indicate the program additions.
In the Push-UP stage S1, we add the Set Stage Bit S6
instruction. When contact X0 opens, we transition from S1
and go to two new active states: S2 and S6. In the PushDOWN state S4, we make the same additions. So, any time
someone presses the door control pushbutton, the light turns
on.
Most new stage programmers would be concerned about
where to place the Light Stage in the ladder, and how to
number it. The good news is that it doesn’t matter!
• Choose an unused Stage number, and use it for the new stage
and as the reference from other stages.
ISG
S0
DOWN State
S1
X0
JMP
SG
S1
Push–UP State
S2
X0
JMP
S6
SET
SG
S2
RAISE State
• Placement in the program is not critical, so we place it at the
end.
SP1
You might think that each stage has to be directly under the
stage that transitions to it. While it is good practice, it is not
required (that’s good, because our two locations for the Set
S6 instruction make that impossible). Stage numbers and
how they are used determines the transition paths.
In stage S6, we turn on the safety light by energizing Y3.
Special relay contact SP1 is always on. Timer T0 times at 0.1
second per count. To achieve 3 minutes time period, we
calculate:
X1
Y1
OUT
S3
JMP
SG
S3
UP State
S4
X0
JMP
SG
S4
Push–DOWN State
S5
X0
JMP
3 min. x 60 sec/min
0.1 sec/count
K = 1800 counts
S6
K=
SET
SG
S5
LOWER State
SP1
The timer has power flow whenever stage S6 is active. The
corresponding timer bit T0 is set when the timer expires. So
three minutes later, T0=1 and the instruction Reset S6 causes
the stage to be inactive.
While Stage S6 is active and the light is on, stage transitions
in the primary path continue normally and independently of
Stage 6. That is, the door can go up, down, or whatever, but
the light will be on for precisely 3 minutes.
Y2
OUT
S0
X2
JMP
SG
S6
LIGHT State
SP1
Y3
OUT
TMR T0
K1800
T0
S6
RST
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–13
Chapter 7: RLLPLUS Stage Programming
Add Emergency Stop Feature
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
Some garage door openers today will detect an object under
the door. This halts further lowering of the door. Usually
implemented with a photocell (“electric-eye”), a door in the
process of being lowered will halt and begin raising. We will
define our safety feature to work in this way, adding the
input from the photocell to the block diagram as shown to
the right. X3 will be on if an object is in the path of the
door.
Next, we make a simple addition to the state transition
diagram, shown in shaded areas in the figure below. Note
the new transition path at the top of the LOWER state. If
we are lowering the door and detect an obstruction (X3),
we then jump to the Push-UP State. We do this instead of
jumping directly to the RAISE state, to give the Lower
output Y2 one scan to turn off, before the Raise output Y1
energizes.
X0
X0
RAISE
Push–UP
Inputs
Toggle
Up limit
Outputs
X0
Y1
X1
Y2
Down limit
X2
Ladder
Program
Y3
Raise
Lower
Light
Obstruction
X3
X1
X0
DOWN
X2
X3
X3
LIGHT
UP
T0
X0
LOWER
Push–DOWN
X0
X0
Exclusive Transitions
7–14
It is theoretically possible the down limit (X2) and the obstruction input (X3) could energize
at the same moment. In that case, we would “jump” to the Push-UP and DOWN states
simultaneously, which does not make sense.
Instead, we give priority to the obstruction by
changing the transition condition to the DOWN
SG
LOWER State
S5
state to [X2 AND NOT X3]. This ensures the
obstruction event has the priority. The
SP1
Y2
modifications we must make to the LOWER Stage
OUT
(S5) logic are shown to the right. The first rung
to DOWN
S0
X2
X3
remains unchanged. The second and third rungs
JMP
implement the transitions we need. Note the
opposite relay contact usage for X3, which ensures
S2
to Push-UP
X3
the stage will execute only one of the JMP
JMP
instructions.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Stage Program Design Considerations
Stage Program Organization
The examples so far in this chapter used one self-contained state diagram to represent the
main process. However, we can have multiple processes implemented in stages, all in the same
ladder program. New stage programmers sometimes try to turn a stage on and off each scan,
based on the false assumption that only one stage can be on at a time. For ladder rungs that
you want to execute each scan, put them in a stage that is always on.
The following figure shows a typical application. During operation, the primary
manufacturing activity Main Process, Powerup Initialization, E-Stop and Alarm Monitoring,
and Operator Interface are all running. At powerup, four initial stages shown begin operation.
XXX
= ISG
Main Process
Powerup Initialization
Powerup
Idle
Agitate
Fill
E-Stop and Alarm Monitoring
Rinse
Spin
Operator Interface
Monitor
Recipe
Control
Status
In a typical application, the separate stage sequences above operate as follows:
• Powerup Initialization – This stage contains ladder rung tasks performed once at powerup. Its last
rung resets the stage, so this stage is only active for one scan (or only as many scans that are
required)
• Main Process – This stage sequence controls the heart of the process or machine. One pass through
the sequence represents one part cycle of the machine, or one batch in the process.
• E-Stop and Alarm Monitoring – This stage is always active because it is watching for errors that
could indicate an alarm condition or require an emergency stop. It is common for this stage to reset
stages in the main process or elsewhere, in order to initialize them after an error condition.
• Operator Interface – This is another task that must always be active and ready to respond to an
operator. It allows an operator interface to change modes, etc., independently of the current main
process step.
Although we have separate processes, there can be
coordination among them. For example, in an error
condition, the Status Stage may want to
automatically switch the operator interface to the
status mode to show error information as shown to
the right. The monitor stage could set the stage bit
for Status and Reset the stages Control and Recipe.
Operator Interface
Recipe
Control
Monitor
Status
E-Stop and
Alarm Monitoring
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–15
Chapter 7: RLLPLUS Stage Programming
How Instructions Work Inside Stages
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–16
We can think of states or stages as simply dividing up our ladder program as depicted in the
figure below. Each stage contains only the ladder rungs which are needed for the
corresponding state of the process. The logic for transitioning out of a stage is contained
within that stage. It’s easy to choose which ladder rungs are active at powerup by using an
“initial” stage type (ISG).
Stage 0
Stage 1
Stage 2
Most instructions work like they do in standard RLL. You can think of a stage like a
miniature RLL program which is either active or inactive.
Output Coils – As expected, output coils in active stages will turn on or off outputs
according to power flow into the coil. However, note the following:
• Outputs work as usual, provided each output reference (such as “Y3”) is used in only one stage.
• Output coils automatically turn off when leaving a stage. However, Set and Reset instructions are
not “undone” when leaving a stage.
• An output can be referenced from more than one stage, as long as only one of the stages is active at
a time.
• If an output coil is controlled by more than one stage simultaneously, the active stage nearest the
bottom of the program determines the final output status during each scan. So, use the OROUT
instruction instead when you want multiple stages to have a logical OR control of an output.
One-Shot or PD coils – Use care if you must use a Positive Differential coil in a stage.
Remember the input to the coil must make a 0–1 transition. If the coil is already energized on
the first scan when the stage becomes active, the PD coil will not work. This is because the
0–1 transition did not occur.
PD coil alternative: If there is a task which you want to do only once (on 1 scan), it can be
placed in a stage which transitions to the next stage on the same scan.
Counter – When using a counter inside a stage, the stage must be active for one scan before
the input to the counter makes a 0–1 transition. Otherwise, there is no real transition and the
counter will not count. The ordinary Counter instruction does have a restriction inside stages:
it may not be reset from other stages using the RST instruction for the counter bit. However,
the special Stage Counter provides a solution (see next paragraph).
Stage Counter – The Stage Counter has the benefit that its count may be globally reset from
other stages by using the RST instruction. It has a count input, but no reset input. This is the
only difference from a standard counter instruction.
Drum – Realize the drum sequencer is its own process, and is a different programming
method than stage programming. If you need to use a drum and stages, be sure to place the
drum instruction in an ISG stage that is always active.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Using a Stage as a Supervisory Process
You may recall the light bulb on-off controller
example from earlier in this chapter. For the purpose
of illustration, suppose we want to monitor the
“productivity” of the lamp process, by counting the
number of on-off cycles which occurs. This
application will require the addition of a simple
counter, but the key decision is in where to put the
counter.
Toggle
X0
Ladder Y0
Program
Powerup
Powerup
ISG
S0
Supervisor Process
Supervisor
OFF State
S1
X0
X0
Push–ON
X0
Main Process
OFF
JMP
SG
S1
ON
Push–On State
S2
X0
JMP
X0
Push–OFF
X0
New stage programming students will typically try to place
the counter inside one of the stages of the process they are
trying to monitor. The problem with this approach is that
the stage is active only part of the time. In order for the
counter to count, the count input must transition from off
to on at least one scan after its stage activates. Ensuring this
requires extra logic that can be tricky. In this case, we only
need to add another supervisory stage as shown above, to
“watch” the main process. The counter inside the supervisor
stage uses the stage bit S1 of the main process as its count
input. Stage bits used as a contact let us monitor a process!
NOTE: Both the Supervisor stage and the OFF stage are initial
stages. The supervisor stage remains active indefinitely.
SG
S2
ON State
SP1
Y0
OUT
S3
X0
JMP
SG
S3
Push–Off State
S0
X0
JMP
ISG
S4
Supervisor State
S1
SGCNT
CT0
K5000
Stage Counter
The counter in the above example is a special Stage Counter. Note that it does not have a
reset input. The count is reset by executing a Reset instruction, naming the counter bit (CT0
in this case). The Stage Counter has the benefit that its count may be globally reset from
other stages. The standard Counter instruction does not have this global reset capability. You
may still use a regular Counter instruction inside a stage... however, the reset input to the
counter is the only way to reset it.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–17
Chapter 7: RLLPLUS Stage Programming
Unconditional Outputs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
As in most example programs in this chapter
and Stage 0 to the right, your application
may require a particular output to be ON
unconditionally when a particular stage is
active. Until now, the examples always use
the SP1 special relay contact (always on) in
series with the output coils. It’s possible to
omit the contact, as long as you place any
unconditional outputs first (at the top) of a
stage section of ladder. The first rung of
Stage 1 does this.
SG
S0
Unconditional
Output
SG
S1
SG
S2
WARNING: Unconditional outputs placed
elsewhere in a stage do not necessarily remain
on when the stage is active. In Stage 2 to the
right, Y0 is shown as an unconditional output,
but its powerflow comes from the rung above.
So, Y0 status will be the same as Y1 is not
correct.
SP1
Y0
OUT
Y0
OUT
X0
Y1
OUT
X0
Y1
OUT
Y0
OUT
Power Flow Transition Technique
7–18
Our discussion of state transitions has shown how the Stage JMP instruction makes the
current stage inactive and the next stage (named in the JMP) active. As an alternative way to
enter this in DirectSOFT, you may use the power flow method for stage transitions. The main
requirement is the current stage be located directly above the next (jump-to) stage in the
ladder program. This arrangement is shown in the diagram below, by stages S0 and S1,
respectively.
X0
S0
SG
S0
SG
S1
X0
SG
S0
S1
JMP
S1
All other rungs in stage...
X0
Equivalent
Power flow
transition
SG
S1
Recall the Stage JMP instruction may occur anywhere in the current stage, and the result is
the same. However, power flow transitions (shown above) must occur as the last rung in a
stage. All other rungs in the stage will precede it. The power flow transition method is also
achievable on the handheld programmer, by simply following the transition condition with
the Stage instruction for the next stage.
The power flow transition method does eliminate one Stage JMP instruction, its only
advantage. However, it is not as easy to make program changes as using the Stage JMP.
Therefore, we advise using Stage JMP transitions for most programs.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Parallel Processing Concepts
Parallel Processes
Previously in this chapter we discussed how a state may transition to either one state or
another, called an exclusive transition. In other cases, we may need to branch simultaneously
to two or more parallel processes, as shown below. It is acceptable to use all JMP instructions
as shown, or we could use one JMP and a Set Stage bit instruction(s) (at least one must be a
JMP, in order to leave S1). Remember that all instructions in a stage execute, even when it
transitions (the JMP is not a GOTO).
Process A
S0
S1
S2
SG
S1
S3
S2
X0
X0
Process B
Push–On State
JMP
S4
S4
S5
JMP
Note that if we want Stages S2 and S4 to energize exactly on the same scan, both stages must
be located below Stage S1 in the ladder program (see the explanation at the bottom of page
7–7). Overall, parallel branching is easy!
Converging Processes
Now we consider the opposite case of parallel branching, which is converging processes. This
simply means we stop doing multiple things and continue doing one thing at a time. In the
figure below, processes A and B converge when stages S2 and S4 transition to S5 at some
point in time. So, S2 and S4 are Convergence Stages.
Process A
S1
S2
= Convergence Stage
S5
Process B
S3
S6
S4
Convergence Stages (CV)
ý
þ 240
þ 250-1
þ 260
230
While the converging principle is simple enough, it brings a new complication. As parallel
processing completes, the multiple processes almost never finish at the same time. In other
words, how can we know whether Stage S2 or S4 will finish last? This is an important point,
because we have to decide how to transition to Stage S5.
CV
Convergence
The solution is to coordinate the transition condition out of
S2
Stages
convergence stages. We accomplish this with a stage type
designed for this purpose: the Convergence Stage (type CV). In
CV
S4
the example to the right, convergence stages S2 and S4 are
required to be grouped together as shown. No logic is permitted
X3
S5
between CV stages! The transition condition (X3 in this case)
CVJMP
must be located in the last convergence stage. The transition
SG
condition only has power flow when all convergence stages in
S5
the group are active.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–19
Chapter 7: RLLPLUS Stage Programming
Convergence Jump (CVJMP)
1 ý
2 þ
þ
3 þ
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
230
240
250-1
260
Recall the last convergence stage only has power flow
when all CV stages in the group are active. To
complement the convergence stage, we need a new
jump instruction. The Convergence Jump (CVJMP)
shown to the right will transition to Stage S5 when
X3 is active (as one might expect), but it also
automatically resets all convergence stages in the group.
This makes the CVJMP jump a very powerful
instruction. Note that this instruction may only be
used with convergence stages.
CV
S2
Convergence
Jump
CV
S4
X3
S5
CVJMP
SG
S5
Convergence Stage Guidelines
7–20
The following summarizes the requirements in the use of convergence stages, including some
tips for their effective application:
• A convergence stage is to be used as the last stage of a process which is running in parallel to another
process or processes. A transition to the convergence stage means that a particular process is
through, and represents a waiting point until all other parallel processes also finish.
• The maximum number of convergence stages which make up one group is 17. In other words, a
maximum of 17 stages can converge into one stage.
• Convergence stages of the same group must be placed together in the program, connected on the
power rail without any other logic in between.
• Within a convergence group, the stages may occur in any order, top to bottom. It does not matter
which stage is last in the group, because all convergence stages have to be active before the last stage
has power flow.
• The last convergence stage of a group may have ladder logic within the stage. However, this logic
will not execute until all convergence stages of the group are active.
• The convergence jump (CVJMP) is the intended method to be used to transition from the
convergence group of stages to the next stage. The CVJMP resets all convergence stages of the
group, and energizes the stage named in the jump.
• The CVJMP instruction must only be used in a convergence stage, as it is invalid in regular or
initial stages.
• Convergence Stages or CVJMP instructions may not be used in subroutines or interrupt routines.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
Managing Large Programs
A stage may contain a lot of ladder rungs, or only one or two program rungs. For most
applications, good program design will ensure the average number of rungs per stage will be
small. However, large application programs will still create a large number of stages. We
introduce a new construct which will help us organize related stages into groups called blocks.
So, program organization is the main benefit of the use of stage blocks.
Stage Blocks (BLK, BEND)
ý 230
þ 240
þ 250-1
þ 260
A block is a section of ladder program which contains stages. In the figure below, each block
has its own reference number. Like stages, a stage block may be active or inactive. Stages
inside a block are not limited in how they may transition from one to another. Note the use
of stage blocks does not require each stage in a program to reside inside a block, shown below
by the “stages outside blocks”.
Block 1
Block 2
PLUS
Block 0
Stages outside blocks:
A program with 20 or more stages may be considered large enough to use block grouping
(however, their use is not mandatory). When used, the number of stage blocks should
probably be two or higher, because the use of one block provides a negligible advantage.
A block of stages is separated from other ladder
logic with special beginning and ending
BLK
instructions. In the figure to the right, the BLK
Block Instruction
C0
instruction at the top marks the start of the stage
block. At the bottom, the Block End (BEND)
SG
marks the end of the block. The stages in between
S0
these boundary markers (S0 and S1 in this case)
All other rungs in stage...
and their associated rungs make up the block.
SG
Note the block instruction has a reference value
S1
field (set to “C0” in the example). The block
All other rungs in stage...
instruction borrows or uses a control relay contact
number, so that other parts of the program can
Block End
Instruction
control the block. Any control relay number (such as
BEND
C0) used in a BLK instruction is not available for
use as a control relay.
NOTE: The stages within a block must be regular stages (SG) or convergence stages (CV). So, they cannot
be initial stages. The numbering of stages inside stage blocks can be in any order, and is completely
independent from the numbering of the blocks.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–21
Chapter 7: RLLPLUS Stage Programming
Block Call (BCALL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
ý 230
þ 240
þ 250-1
þ 260
7–22
The purpose of the Block Call instruction is to activate a stage block. At powerup or upon
Program-to-Run mode transitions, all stage blocks and the stages within them are inactive.
Shown in the figure below, the Block Call instruction is a type of output coil. When the X0
contact is closed, the BCALL will cause the stage block referenced in the instruction (C0) to
become active. When the BCALL is turned off, the corresponding stage block and the stages
within it become inactive.
We must avoid confusing block call operation with how a “subroutine call” works. After a
BCALL coil executes, program execution continues with the next program rung. Whenever
program execution arrives at the ladder location of the stage block named in the BCALL,
then logic within the block executes because the block is now active. Similarly, do not classify
the BCALL as type of state transition (is not a JMP).
X0
Block C0
C0
BCALL
(next rung)
Activate
When a stage block becomes active, the first stage in the block automatically becomes active
on the same scan. The “first” stage in a block is the one located immediately under the block
(BLK) instruction in the ladder program. So, that stage plays a similar role to the initial type
stage we discussed earlier.
The Block Call instruction may be used in several contexts. Obviously, the first execution of a
BCALL must occur outside a stage block, since stage blocks are initially inactive. Still, the
BCALL may occur on an ordinary ladder rung, or it may occur within an active stage as
shown below. Note that either turning off the BCALL or turning off the stage containing the
BCALL will deactivate the corresponding stage block. You may also control a stage block with
a BCALL in another stage block.
SG
S0
X0
C0
BCALL
All other rungs in stage...
SG
S11
BLK
C0
SG
S10
SG
S11
Stage Block
All rungs in stage...
All other rungs in stage...
BEND
NOTE: Stage Block may come before or after the location of the BCALL instruction in the program.
The BCALL may be used in many ways or contexts, so it can be difficult to find the best
usage. Remember the purpose of stage blocks is to help you organize the application problem
by grouping related stages together. Remember that initial stages must exist outside stage
blocks.
DL205 User Manual, 4th Edition, Rev. B
Chapter 7: RLLPLUS Stage Programming
RLLPLUS (Stage) Instructions
Stage (SG)
þ 230
þ 240
þ 250-1
þ 260
The Stage instructions are used to create structured RLLPLUS
programs. Stages are program segments which can be activated by
transitional logic, a jump or a set stage that is executed from an
active stage. Stages are deactivated one scan after transitional logic,
a jump, or a reset stage instruction is executed.
Operand Data Type
Stage
SG
S aaa
DL230 Range
DL240 Range
DL250-1 Range
aaa
aaa
aaa
aaa
0-377
0-777
0-1777
0-1777
S
DL260 Range
The following example is a simple RLLPLUS program. This program utilizes the initial stage,
stage, and jump instruction to create a structured program.
DirectSOFT
ISG
Handheld Programmer Keystrokes
S0
X0
Y10
OUT
X1
X5
SG
0
ENT
X(IN)
0
ENT
OUT
Y(OUT)
1
0
STR
X(IN)
1
ENT
SET
S(SG)
2
ENT
STR
X(IN)
5
ENT
ENT
S2
JMP
S(SG)
1
SG
S(SG)
1
ENT
S1
STR
X(IN)
2
ENT
JMP
OUT
Y(OUT)
1
1
Y11
OUT
SG
S(SG)
STR
SET
S1
X2
ISG
SG
S(SG)
2
ENT
STR
X(IN)
6
ENT
OUT
Y(OUT)
1
2
STR
X(IN)
7
ENT
AND
S(SG)
1
ENT
JMP
S(SG)
0
ENT
S2
X6
Y12
OUT
X7
S1
S0
JMP
DL205 User Manual, 4th Edition, Rev. B
ENT
ENT
ENT
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–23
Chapter 7: RLLPLUS Stage Programming
Initial Stage (ISG)
The Initial Stage instruction is normally used as the first
1 þ
segment of an RLL
program. Initial stages will be active
ISG
when the CPU enters the run mode allowing for a starting
S aaa
point in the program. Initial Stages are also activated by
2 þ
transitional logic, a jump or a set stage executed from an
þ
active stage. Initial Stages are deactivated one scan after
þ
3
transitional logic, a jump, or a reset stage instruction is
executed. Multiple Initial Stages are allowed in a program.
4 Operand Data Type DL230 Range DL240 Range DL250-1 Range DL260 Range
aaa
aaa
aaa
aaa
5
6
NOTE: If the ISG is within the retentive range for stages, the ISG will remain in the state it was in before
power down and will NOT turn itself on during the first scan.
7
Jump (JMP)
The Jump instruction allows the program to transition from
8 þ
an active stage which contains the jump instruction to
another stage which is specified in the instruction. The jump
9 þ
will occur when the input logic is true. The active stage that
þ
contains the Jump will be deactivated 1 scan after the Jump
instruction is executed.
10 þ
11 Operand Data Type DL230aaaRange DL240aaaRange DL250-1aaaRange DL260aaaRange
12
(NJMP)
13 Not Jump
The Not Jump instruction allows the program to transition
from an active stage which contains the jump instruction to
þ
another which is specified in the instruction. The jump will
14 þ
occur when the input logic is off. The active stage that
þ
contains the Not Jump will be deactivated 1 scan after the
A þ
Not Jump instruction is executed.
B Operand Data Type DL230 Range DL240 Range DL250-1 Range DL260 Range
aaa
aaa
aaa
aaa
C
D
PLUS
230
240
250-1
260
Stage
S
0-377
0-777
0-1777
230
0-1777
S aaa
240
JMP
250-1
260
Stage
S
0-377
0-777
0-1777
230
0-1777
S aaa
240
NJMP
250-1
260
Stage
7–24
S
0-377
0-777
DL205 User Manual, 4th Edition, Rev. B
0-1777
0-1777
Chapter 7: RLLPLUS Stage Programming
In the following example, when the CPU begins program execution only ISG 0 will be active.
When X1 is on, the program execution will jump from Initial Stage 0 to Stage 1. In Stage 1,
if X2 is on, output Y5 will be turned on. If X7 is on, program execution will jump from Stage
1 to Stage 2. If X7 is off, program execution will jump from Stage 1 to Stage 3.
DirectSOFT
ISG
Handheld Programmer Keystrokes
S(SG)
0
ENT
X(IN)
1
ENT
JMP
S(SG)
1
ENT
S1
SG
S(SG)
1
ENT
JMP
STR
X(IN)
2
ENT
OUT
Y(OUT)
5
ENT
STR
X(IN)
7
ENT
JMP
S(SG)
2
ENT
S0
X1
SG
S1
X2
Y5
SHFT
N
JMP
OUT
S(SG)
3
ENT
S2
X7
JMP
S3
NJMP
Converge Stage (CV) and Converge Jump (CVJMP)
ý
þ 240
þ 250-1
þ 260
230
The Converge Stage instruction is used to group certain
stages together by defining them as Converge Stages.
When all of the Converge Stages within a group become
active, the CVJMP instruction (and any additional logic in
the final CV stage) will be executed. All preceding CV stages
must be active before the final CV stage logic can be
executed. All Converge Stages are deactivated one scan after
the CVJMP instruction is executed.
Additional logic instructions are only allowed following the
last Converge Stage instruction and before the CVJMP
instruction. Multiple CVJUMP instructions are allowed.
Converge Stages must be programmed in the main body of
the application program. This means they cannot be
programmed in Subroutines or Interrupt Routines.
Operand Data Type
Stage
S
CV
S aaa
S aaa
CVJMP
DL240 Range
DL250-1 Range
aaa
aaa
DL260 Range
aaa
0-777
0-1777
0-1777
DL205 User Manual, 4th Edition, Rev. B
Stage Programming
ISG
STR
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–25
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
In the following example, when Converge Stages S10 and S11 are both active the CVJMP
instruction will be executed when X4 is on. The CVJMP will deactivate S10 and S11, and
activate S20. Then, if X5 is on, the program execution will jump back to the initial stage, S0.
Handheld Programmer Keystrokes
DirectSOFT
ISG
S0
X0
X1
SG
S(SG)
0
ENT
STR
X(IN)
0
ENT
OUT
Y(OUT)
0
ENT
STR
X(IN)
1
ENT
Y0
JMP
S(SG)
1
ENT
OUT
JMP
S(SG)
1
0
S1
JMP
SG
S(SG)
1
ENT
STR
X(IN)
2
ENT
S10
JMP
S(SG)
1
1
ENT
SHFT
C
V
S(SG)
1
0
ENT
SHFT
C
V
S(SG)
1
1
ENT
S1
X2
ISG
JMP
STR
X(IN)
OUT
S11
STR
JMP
SHFT
CV
S10
X4
SG
7–26
3
ENT
X(IN)
4
ENT
SHFT
JMP
S(SG)
2
0
ENT
STR
X(IN)
5
ENT
JMP
S(SG)
0
ENT
Y3
OUT
S20
CVJMP
S20
X5
Y(OUT)
V
S11
X3
ENT
S(SG)
C
SG
CV
3
ENT
S0
JMP
DL205 User Manual, 4th Edition, Rev. B
2
0
ENT
Chapter 7: RLLPLUS Stage Programming
Block Call (BCALL)
ý 230
þ 240
þ 250-1
þ 260
C aaa
The stage block instructions are used to activate a block of
stages. The Block Call, Block, and Block End instructions
BCALL
must be used together. The BCALL instruction is used to
activate a stage block. There are several things you need to
know about the BCALL instruction.
• Uses CR Numbers — The BCALL appears as an output coil, but does not actually refer to a
Stage number as you might think. Instead, the block is identified with a Control Relay
(Caaa). This control relay cannot be used as an output anywhere else in the program.
• Must Remain Active — The BCALL instruction actually controls all the stages between the
BLK and the BEND instructions even after the stages inside the block have started
executing. The BCALL must remain active or all the stages in the block will automatically
be turned off. If either the BCALL instruction, or the stage that contains the BCALL instruction
goes off, then the stages in the defined block will be turned off automatically.
• Activates First Block Stage — When the BCALL is executed it automatically activates the
first stage following the BLK instructions.
Operand Data Type
Control Relay
C
DL240 Range
DL250-1 Range
aaa
aaa
DL260 Range
aaa
0-777
0-1777
0-3777
Block (BLK)
ý 230
þ 240
þ 250-1
þ 260
The Block instruction is a label which marks the beginning
of a block of stages that can be activated as a group. A Stage
instruction must immediately follow the Start Block
instruction. Initial Stage instructions are not allowed in a
block. The control relay (Caaa) specified in Block instruction
must not be used as an output anywhere else in the program.
BLK
C aaa
Block End (BEND)
ý 230
þ 240
þ 250-1
þ 260
The Block End instruction is a label used with the Block
instruction. It marks the end of a block of stages. There is no
operand with this instruction. Only one Block End is
allowed per Block Call.
Operand Data Type
Control Relay
C
BEND
DL240 Range
DL250-1 Range
aaa
aaa
DL260 Range
aaa
0-777
0-1777
0-3777
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–27
Chapter 7: RLLPLUS Stage Programming
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
In this example, the Block Call is executed when
stage 1 is active and X6 is on. The Block Call then
automatically activates stage S10, which
immediately follows the Block instruction.
This allows the stages between S10 and the Block
End instruction to operate as programmed. If the
BCALL instruction is turned off, or if the stage
containing the BCALL instruction is turned off,
then all stages between the BLK and BEND
instructions are automatically turned off.
If you examine S15, you will notice that X7 could
reset Stage S1, which would disable the BCALL,
thus resetting all stages within the block.
DirectSOFT
SG
S1
Y5
X2
OUT
C0
BCALL
X6
BLK
SG
C0
S10
Y6
X3
OUT
BEND
Handheld Programmer Keystrokes
SG
S(SG)
1
ENT
STR
X(IN)
2
ENT
OUT
Y(OUT)
5
ENT
STR
X(IN)
6
ENT
L
SG
B
C
A
SHFT
B
L
K
S(SG)
1
STR
X(IN)
3
ENT
OUT
Y(OUT)
6
ENT
E
N
D
ENT
ENT
SHFT
B
L
C(CR)
C(CR)
0
SG
S(SG)
1
5
STR
X(IN)
7
ENT
RST
S(SG)
1
ENT
S1
X7
SHFT
SG
S15
0
RST
0
ENT
ENT
ENT
Stage View in DirectSOFT
7–28
The Stage View option in DirectSOFT will let you view the ladder program as a flow chart.
The figure below shows the symbol convention used in the diagrams. You may find the stage
view useful as a tool to verify that your stage program has faithfully reproduced the logic of
the state transition diagram you intend to realize.
SG
Stage
Transition
Logic
Reference to
a Stage
J
Jump
Output
S
Set Stage
R
Reset Stage
The following diagram is a typical stage view of a ladder program containing stages. Note the
left-to-right direction of the flow chart.
ISG
S0
J
SG
S1
DL205 User Manual, 4th Edition, Rev. B
J
SG
S2
S
SG
S4
J
SG
S3
J
SG
S5
Chapter 7: RLLPLUS Stage Programming
Questions and Answers about Stage Programming
We include the following commonly-asked questions about Stage Programming as an aid to
new students. All question topics are covered in more detail in this chapter.
Q. What does stage programming do that I can’t do with regular RLL programs?
A. Stages allow you to identify all the states of your process before you begin programming.
This approach is more organized, because you divide up a ladder program into sections. As
stages, these program sections are active only when they are actually needed by the process.
Most processes can be organized into a sequence of stages, connected by event-based
transitions.
Q. Isn’t a stage really like a software subroutine?
A. No, it is very different. A subroutine is called by a main program when needed, and
executes only once before returning to the point from which it was called. A stage,
however, is part of the main program. It represents a state of the process, so an active stage
executes on every scan of the CPU until it becomes inactive.
Q. What are Stage Bits?
A. A stage bit is a single bit in the CPU’s image register, representing the active/inactive status
of the stage in real time. For example, the bit for Stage 0 is referenced as “S0”. If S0 = 0,
then the ladder rungs in Stage 0 are bypassed (not executed) on each CPU scan. If S0 = 1,
then the ladder rungs in Stage 0 are executed on each CPU scan. Stage bits, when used as
contacts, allow one part of your program to monitor another part by detecting stage
active/inactive status.
Q. How does a stage become active?
A. There are three ways:
• If the Stage is an initial stage (ISG), it is automatically active at powerup.
• Another stage can execute a Stage JMP instruction naming this stage, which makes it active upon its
next occurrence in the program.
• A program rung can execute a Set Stage Bit instruction (such as SET S0).
Q. How does a stage become inactive?
A. There are three ways:
• Standard Stages (SG) are automatically inactive at powerup.
• A stage can execute a Stage JMP instruction, resetting its Stage Bit to 0.
• Any rung in the program can execute a Reset Stage Bit instruction (such as RST S0).
Q. What about the power flow technique of stage transitions?
A. The power flow method of connecting adjacent stages (directly above or below in the
program) actually is the same as the Stage Jump instruction executed in the stage above,
naming the stage below. Power flow transitions are more difficult to edit in DirectSOFT,
we list them separately from two preceding questions.
DL205 User Manual, 4th Edition, Rev. B
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
7–29
Chapter 7: RLLPLUS Stage Programming
Q. Can I have a stage which is active for only one scan?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A
B
C
D
A. Yes, but this is not the intended use for a stage. Instead, make a ladder rung active for one
scan by including a stage Jump instruction at the bottom of the rung. Then the ladder will
execute on the last scan before its stage jumps to a new one.
Q. Isn’t a Stage JMP just like a regular GOTO instruction used in software?
A. No, it is very different. A GOTO instruction sends the program execution immediately to
the code location named by the GOTO. A Stage JMP simply resets the Stage Bit of the
current stage, while setting the Stage Bit of the stage named in the JMP instruction. Stage
bits are 0 or 1, determining the inactive/active status of the corresponding stages. A stage
JMP has the following results:
• When the JMP is executed, the remainder of the current stage’s rungs are executed, even if they
reside past(under) the JMP instruction. On the following scan, that stage is not executed, because it
is inactive.
• The Stage named in the Stage JMP instruction will be executed upon its next occurrence. If located
past (under) the current stage, it will be executed on the same scan. If located before (above) the
current stage, it will be executed on the following scan.
Q. How can I know when to use stage JMP, versus a Set Stage Bit or Reset Stage
Bit?
A. These instructions are used according to the state diagram topology you have derived:
• Use a Stage JMP instruction for a state transition... moving from one state to another.
• Use a Set Stage Bit instruction when the current state is spawning a new parallel state or stage
sequence, or when a supervisory state is starting a state sequence under its command.
• Use a Reset Bit instruction when the current state is the last state in a sequence and its task is
complete, or when a supervisory state is ending a state sequence under its command.
Q. What is an initial stage, and when do I use it?
A. An initial stage (ISG) is automatically active at powerup. Afterwards, it works just like any
other stage. You can have multiple initial stages, if required. Use an initial stage for ladder
that must always be active, or as a starting point.
Q. Can I have place program ladder rungs outside of the stages, so they are
always on?
A. It is possible, but it’s not good software design practice. Place ladder that must always be
active in an initial stage, and do not reset that stage or use a Stage JMP instruction inside
it. It can start other stage sequences at the proper time by setting the appropriate Stage
Bit(s).
Q. Can I have more than one active stage at a time?
7–30
A. Yes, and this is a normal occurrence for many programs. However, it is important to
organize your application into separate processes, each made up of stages. And a good
process design will be mostly sequential, with only one stage on at a time. However, all the
processes in the program may be active simultaneously.
DL205 User Manual, 4th Edition, Rev. B
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement