Download Stage Programming - AutomationDirect

RLL PLUS
Stage Programming
17
In This Chapter. . . .
— Introduction to Stage Programming
— Learning to Draw State Transition Diagrams
— Using the Stage Jump Instruction for State Transitions
— Stage Program Example: Toggle On/Off Lamp Controller
— Four Steps to Writing a Stage Program
— Stage Program Example: a Garage Door Opener
— Stage Program Design Considerations
— Parallel Processing Concepts
— Managing Large Programs
— RLL PLUS Instructions
— Questions and Answers About Stage Programming
7--2
RLL PLUS Stage Programming
Introduction to Stage Programming
RLL PLUS
Stage Programming
430 440 450
Overcoming
“Stage Fright”
Stage Programming (available in all DL405 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 RLL PLUS. You won’t 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.
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:
S Large programs can become almost
unmanageable, because of a lack of
structure.
S In RLL, latches must be tediously
created from self-latching relays.
S When a process gets stuck, it is
difficult to find the rung where the
error occurred.
S Programs become difficult to modify
later, because they do not intuitively
resemble the application problem
they are solving.
X0
X4
C0
RST
C1
Y0
SET
STAGE!
X3
Y2
OUT
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:
S Start at the beginning and do not skip over any sections.
S Study each stage programing concept by working through each
example. The examples build progressively on each other.
S Read the Stage Questions and Answers at the end of the chapter for a
quick review.
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS Stage Programming
7--3
Learning to Draw State Transition Diagrams
Introduction to
Process States
Inputs
Ladder
Program
Outputs
PLC Scan
1) Read
Execute
Write
2) Read
Execute
Write
3) Read
(etc....)
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 just 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 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
Diagrams
analysis of an application gives us the best chance at writing efficient, bug-free
programs. State diagrams are just a tool to help us draw a picture of our process!
You’ll discover that if we can get the picture right, our program will also be right!
Inputs
Outputs
A 2--State Process Consider the simple process shown to the
right, which controls an industrial motor.
On
We will use a green momentary SPST
X0
Motor
pushbutton to turn the motor on, and a red
Ladder Y0
one to turn it off. The machine operator will
Program
Off
X1
press the appropriate pushbutton for just a
second or so. The two states of our
process are ON and OFF.
Transition condition
The next step is to draw a state transition
State
diagram, as shown to the right. It shows
X0
the two states OFF and ON, with two
transition lines in-between. When the
OFF
ON
event X0 is true, we transition from OFF to
X1
ON. When X1 is true, we transition from
Output equation: Y0 = ON
ON to OFF.
RLL PLUS
Stage Programming
Those familiar with ladder program
execution know that the CPU must scan
the ladder program repeatedly, over and
over. Its three basic steps are:
1. Read the inputs
2. Execute the ladder program
3. Write the outputs
The benefit is that a change at the inputs
can affect the outputs in just a few
milliseconds.
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.
Next, we will implement the state diagram first as RLL, then as a stage program. This
will help you see the relationship between the two methods in problem solving.
DL405 User Manual, 4th Edition, Rev. A
7--4
RLL PLUS Stage Programming
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!
X0
OFF
ON
X1
Output equation: Y0 = ON
RLL PLUS
Stage Programming
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
Stage Equivalent
The RLL solution is shown to the right.
Output Y0 has a dual purpose. When the
On momentary 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.
The output Y0 has power flow on a field
device.
When the Off pushbutton (X1) is pressed,
it opens the normally-closed X1 contact,
which resets the latch, and output Y0
turns off.
The stage program solution is shown to
the right. The two inline stage boxes S0
and S1 correspond to the two states OFF
and ON. The ladder rung(s) below each
stage box belong to each respective
stage. This means that the PLC only has
to scan those rungs when the
corresponding stage is active!
For now, let’s assume we begin in the OFF
State, so stage S0 is active. When the On
pushbutton (X0) is pressed, a stage
transition occurs. The JMP S1 instruction
executes, which simply turns off the Stage
bit S0 and turns on Stage bit S1. So on the
next PLC scan, the CPU will not execute
Stage S0, but will execute stage S1!
In the On State (Stage S1), we want the
motor to always be on. The special relay
contact SP1 is defined as always on, so Y0
turns the motor on.
Set
Reset
X0
X1
Latch
Y0
OUT
Latch
Y0
SG
S0
OFF State
Transition
S1
X0
JMP
SG
S1
ON State
SP1 Always on
Output
Y0
OUT
Transition
X1
S0
JMP
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.
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS Stage Programming
Let’s Compare
7--5
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
SG
S0
ON states of the state transition diagram
OFF State
below to the stage program at the right. Now,
S1
X0
we challenge anyone to easily identify the
JMP
same states in the RLL program on the
previous page!
SG
SP1
X0
OFF
ON State
S0
JMP
X1
ON
Y0
OUT
X1
Initial Stages
At powerup and Program-to-Run Mode
transitions, the 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 C0 on.
In the stage example to the right, we simply
make Stage S1 an initial stage (ISG) instead of
S0.
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
X1
C0
SP0
C0
OUT
Y0
OUT
ISG
S1
SP1
X1
First Scan
RLL PLUS
Stage Programming
S1
Initial Stage
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.
DL405 User Manual, 4th Edition, Rev. A
7--6
RLL PLUS Stage Programming
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 just a section of ladder program which is either active or
inactive at a given moment. All stage bits (S0 -- 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.
S If Stage bit S0 = 0, its ladder rungs are not scanned (executed).
S 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:
S Execution -- Only logic in active
stages are executed on any scan.
S Transitions -- Stage transition
instructions take effect on the next
occurrence of the stages involved.
S Octal numbering -- Stages are
numbered in octal, like I/O points,
etc. So “S8” is not valid.
S Total Stages -- The maximum
number of stages is CPU-dependent.
S No duplicates -- Each stage number
is unique and can be used just once.
S Any order -- You can skip numbers
and sequence the stage numbers in
any order.
S Last Stage -- the last stage in the
ladder program includes all rungs
from its stage box until the end coil.
DL405 User Manual, 4th Edition, Rev. A
SG
S0
SG
S1
SG
S2
END
7--7
RLL PLUS 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
S1
SG
S0
SG
S0
Equivalent
S1
X0
S0
X0
JMP
RST
S1
RLL PLUS
Stage Programming
S0
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:
S 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!
S The reset will be in effect on the following scan, so the stage that
executed the jump instruction previously will be inactive and bypassed.
S 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
OUT
Y0
OUT
SG
S0
X0
S1
JMP
NOTE: Assume we start with Stage 0 active and Stage 1 inactive for both examples.
DL405 User Manual, 4th Edition, Rev. A
7--8
RLL PLUS Stage Programming
Stage Program Example: Toggle On/Off Lamp Controller
RLL PLUS
Stage Programming
A 4--State Process
In the process shown to the right, we use
an ordinary momentary pushbutton to
control a light bulb. The ladder program
will latch the switch input, so that we will
push and release to turn on the light, push
and release again to turn it off (sometimes
called toggle function). Sure, we could just
buy a mechanical switch with the alternate
on/off action built in... However, this
example is educational and also fun!
Next we draw the state transition diagram.
A typical first approach is to use X0 for
both transitions (like the example shown
to the right). However, this is incorrect
(please keep reading).
Inputs
Toggle
X0
Outputs
Ladder
Program
Powerup
Y0
X0
OFF
ON
X0
Output equation: Y0 = ON
Note that this example differs from the motor example, because now we have just
one pushbutton. When we press the pushbutton, both transition conditions are met.
We would just 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
Push--OFF
X0
JMP
SG
S1
DL405 User Manual, 4th Edition, Rev. A
Push--On State
S2
X0
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!
S1
X0
ON
X0
OFF State
JMP
SG
S2
ON State
SP1
Output
Y0
OUT
S3
X0
JMP
SG
S3
Push--Off State
X0
S0
JMP
RLL PLUS Stage Programming
7--9
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.
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.
S Make lists of inputs and outputs for the process.
S Assign I/O point numbers (X and Y) to physical inputs and outputs.
RLL PLUS
Stage Programming
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.
3. Draw the State Transition Diagram.
The state transition diagram describes the central function of the block diagram,
reading inputs and generating outputs.
S Identify and name the states of the process.
S Identify the event(s) required for each transition between states.
S Ensure the process has a way to re-start itself, or is cyclical.
S Choose the powerup state for your process.
S Write the output equations.
4. Write the Stage Program.
Translate the state transition diagram into a stage program.
S Make each state a stage. Remember to number stages in octal. Up to
384 total stages are available in the DL430 CPU, numbered 0 to 577
octal. Up to 1024 total stages are available in the DL440/DL450 CPUs,
numbered 0 to 1777 in octal.
S Put transition logic inside the stage which originates each transition (the
stage each arrow points away from).
S Use an initial stage (ISG) for any states that must be active at powerup.
S Place the outputs or actions in the appropriate stages.
You’ll notice that Steps 1 through 3 just prepare us to write the stage program in Step
4. However, the program virtually writes itself because of the preparation
beforehand. Soon you’ll be able to start with a word description of an application and
create a stage program in one easy session!
DL405 User Manual, 4th Edition, Rev. A
7--10
RLL PLUS Stage Programming
Stage Program Example: A Garage Door Opener
RLL PLUS
Stage Programming
Garage Door
Opener Example
In this next stage programming example
we’ll 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
push-release 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 just 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.
Draw the Block
Diagram
Up limit switch
Door
Command
Down limit switch
The block diagram of the controller is Inputs
shown to the right. Input X0 is from the
pushbutton door control. Input X1 Toggle X0
energizes when the door reaches the full
up position. Input X2 energizes when the
Up limit
door reaches the full down position. When
X1
the door is positioned between fully up or
down, both limit switches are open.
Down limit
The controller has two outputs to drive the
X2
motor. Y1 is the up (raise the door)
command, and Y2 is the down (lower the
door) command.
DL405 User Manual, 4th Edition, Rev. A
Raise
Lower
Motor
Outputs
To motor:
Ladder
Program Y1
Raise
Y2
Lower
RLL PLUS 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 just one switch for the command input.
Refer to the figure below.
S 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.
S We transition to the UP state when the up limit switch (X1) energizes,
and turns off the motor.
S 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.
X0
Push--UP
X0
RAISE
X1
ISG
S0
DOWN State
S1
JMP
X0
DOWN
X2
UP
LOWER
X0
Push-DOWN
SG
S1
X0
Push--UP State
S2
JMP
X0
SG
S2
Output equations: Y1 = RAISE 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.
RLL PLUS
Stage Programming
Powerup
7--11
RAISE State
SP1
Y1
OUT
X1
S3
JMP
SG
S3
UP State
X0
SG
S4
S4
JMP
Push--DOWN State
X0
SG
S5
S5
JMP
LOWER State
SP1
Y2
OUT
X2
S0
JMP
NOTE: The initial stage (ISG) is automatically active at powerup, afterwards, is acts
like others.
DL405 User Manual, 4th Edition, Rev. A
7--12
RLL PLUS Stage Programming
RLL PLUS
Stage Programming
Add Safety
Light Feature
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
commercially-available 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’ll use the set and reset
commands.
Safety light
To control the light bulb, we add an output Inputs
Modify the
Block Diagram and to our controller block diagram, shown to
Toggle
the right, Y3 is the light control output.
State Diagram
X0
In the diagram below, we add an additional
state called “LIGHT”. Whenever the
garage owner presses the door control Up limit
X1
switch and releases, the RAISE or
LOWER state is active and the LIGHT
state is simultaneously active. The line to
Down limit
the Light state is dashed, because it is not
X2
the primary path.
Outputs
Y1
Ladder
Program Y2
Y3
Raise
Lower
Light
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 just becomes inactive, and the light goes out!
Output equations:
X0
X0
RAISE
Push--UP
X1
Y1 = RAISE
Y2 = LOWER
Y3 = LIGHT
X0
DOWN
LIGHT
UP
T0
X0
X2
LOWER
Push--DOWN
X0
DL405 User Manual, 4th Edition, Rev. A
X0
7--13
RLL PLUS Stage Programming
Using a Timer
Inside a Stage
K=1800 counts
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.
ISG
S0
DOWN State
S1
X0
JMP
SG
S1
Push--UP State
S2
X0
JMP
S6
SET
SG
S2
RAISE State
SP1
Y1
OUT
S3
X1
JMP
SG
S3
RLL PLUS
Stage Programming
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
Push-DOWN 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!
S Just choose an unused Stage
number, and use it for the new stage
and as the reference from other
stages.
S Placement in the program is not
critical, so we place it at the end.
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:
3 min. x 60 sec/min
K=
0.1 sec/count
UP State
S4
X0
JMP
SG
S4
Push--DOWN State
S5
X0
JMP
S6
SET
SG
S5
LOWER State
SP1
Y2
OUT
X2
S0
JMP
SG
S6
LIGHT State
SP1
Y3
OUT
TMR T0
K1800
T0
S6
RST
DL405 User Manual, 4th Edition, Rev. A
7--14
RLL PLUS Stage Programming
RLL PLUS
Stage Programming
Add Emergency
Stop Feature
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.
Inputs
Toggle
Outputs
X0
Y1
X1
Ladder Y2
Program
Down limit
X2
Y3
Up limit
Raise
Lower
Light
Obstruction
X3
X0
X0
RAISE
Push--UP
X1
X0
DOWN
X2 and X3
X3
LIGHT
UP
T0
X0
LOWER
Push--DOWN
X0
X0
Exclusive
Transitions
It is theoretically possible that 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
SG
LOWER State
DOWN state to [X2 AND NOT X3]. This
S5
ensures the obstruction event has the
SP1
Y2
priority. The modifications we must make
OUT
to the LOWER Stage (S5) logic are shown
to the right. The first rung remains
X2
X3 to Push-UP S0
unchanged. The second and third rungs
JMP
implement the transitions we need. Note
S2
X3
to DOWN
the opposite relay contact usage for X3,
which ensures the stage will execute only
JMP
one of the JMP instructions.
DL405 User Manual, 4th Edition, Rev. A
7--15
RLL PLUS Stage Programming
Stage Program Design Considerations
Stage Program
Organization
Main Process
XXX
= ISG
Idle
Powerup Initialization
Powerup
Fill
Agitate
Rinse
E-Stop and Alarm Monitoring
Spin
Operator Interface
Monitor
RLL PLUS
Stage Programming
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, just 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.
Recipe
Control
Status
In a typical application, the separate stage sequences above operate as follows:
S Powerup Initialization -- This stage contains ladder rung tasks done
just 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).
S 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.
S 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.
S 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
Set
Status
E-Stop and
Alarm Monitoring
DL405 User Manual, 4th Edition, Rev. A
7--16
RLL PLUS Stage Programming
We can think of states or stages as simply dividing up our ladder program as
How Instructions
Work Inside Stages 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).
RLL PLUS
Stage Programming
Stage 0
Stage 1
Stage 2
Most all instructions work just like they do in standard RLL. You can think of a stage
just 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:
S Outputs work as usual, provided each output reference (such as “Y3”) is
used in only one stage.
S Output coils automatically turn off when leaving a stage. However, Set
and Reset instructions are not “undone” when leaving a stage.
S An output can be referenced from more than one stage, as long as only
one of the stages is active at a time.
S 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 that 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 -- In 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 that 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.
DL405 User Manual, 4th Edition, Rev. A
7--17
RLL PLUS Stage Programming
Using a Stage as a You may recall the light bulb on-off
controller example from earlier in this
Supervisory
chapter. For the purpose of illustration, Toggle X0
Process
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.
Ladder
Program
Y0
Powerup
Supervisor
X0
OFF
State
S1
JMP
Powerup
X0
Push--ON
X0
Main Process
OFF
X0
Push--OFF
SG
S1
X0
ON
X0
New stage programming students will typically
try to place the counter inside one of the 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!
Push--On
State
S2
JMP
SG
S2
RLL PLUS
Stage Programming
ISG
S0
Supervisor Process
ON State
SP1
Y0
OUT
S3
X0
JMP
SG
S3
X0
Push--Off
State
S0
JMP
ISG
S4
S1
Supervisor
State
SGCNT CT0
K5000
NOTE: Both the Supervisor stage and the OFF stage are initial stages. The
supervisor stage remains active indefinitely.
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.
DL405 User Manual, 4th Edition, Rev. A
7--18
RLL PLUS Stage Programming
RLL PLUS
Stage Programming
Unconditional
Outputs
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.
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 power flow
comes from the rung above. So, Y0 status
will be the same as Y1 (is not correct).
Power Flow
Transition
Technique
SG
S0
SP1
Y0
OUT
Unconditional
Output
SG
S1
Y0
OUT
X0
Y1
OUT
X0
Y1
OUT
SG
S2
Y0
OUT
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 that 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.
S0
X0
SG
S0
S1
SG
S0
X0
S1
All other rungs in stage...
JMP
SG
S1
X0
Equivalent
Power flow
transition
SG
S1
Recall that 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 programmers.
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS Stage Programming
7--19
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
S1
SG
S1
S3
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 or above Stage S1 in the ladder program (see the
explanation at the bottom of page 10--7). Overall, parallel branching is easy!
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.
Converging
Processes
Process A
S1
S2
= Convergence Stage
S5
Process B
Convergence
Stages
(CV)
X 430 440 450
S2
X0
X0
Process B
Push--On State
S3
RLL PLUS
Stage Programming
S0
S2
S6
S4
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.
The solution is to coordinate the transition
condition out of convergence stages. We
accomplish this with a stage type
designed
for
this
purpose:
the
Convergence Stage (type CV). In the
example to the right, convergence stages
S2 and S4 are required to be grouped
together as shown. No logic is permitted
between CV stages! The transition
condition (X3 in this case) must be located
in the last convergence stage. The
transition condition only has power flow
when all convergence stages in the group
are active.
CV
S2
Convergence
Stages
CV
S4
X3
S5
CVJMP
SG
S5
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS
Stage Programming
7--20
RLL PLUS Stage Programming
Convergence Jump Recall that the last convergence stage
only has power flow when all CV stages in
(CVJMP)
the group are active. To complement the
X convergence stage, we need a new jump
430 440 450
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.
Convergence
Stage Guidelines
CV
S2
Convergence
Jump
CV
S4
X3
S5
CVJMP
SG
S5
The following summarizes the requirements in the use of convergence stages,
including some tips for their effective application:
S
S
S
S
S
S
S
S
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.
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS Stage Programming
7--21
Managing Large Programs
430 440 450
Block 0
Block 1
Block 2
RLL PLUS
Stage Programming
Stage Blocks
(BLK, BEND)
X A stage may contain a lot of ladder rungs, or just 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.
A block is a section of ladder program which contains stages. In the figure below,
each block has its own reference number. Just 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 that 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”.
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 instructions. In the figure to the
BLK
Block Instruction
C0
right, the BLK instruction at the top marks
the start of the stage block. At the bottom,
the Block End (BEND) marks the end of
SG
the block. The stages in between these
S0
boundary markers (S0 and S1 in this case)
All other rungs in stage...
and their associated rungs make up the
block.
SG
Note that the block instruction has a
S1
reference value field (set to “C0” in the
All other rungs in stage...
example). The block instruction borrows
or uses a control relay contact number, so
Block End
that other parts of the program can control
Instruction
BEND
the block. Any control relay number (such
as C0) used in a BLK instruction is not
available for use as a control relay.
Note that 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.
DL405 User Manual, 4th Edition, Rev. A
7--22
RLL PLUS Stage Programming
Block Call
(BCALL)
X RLL PLUS
Stage Programming
430 440 450
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).
Block C0
X0
C0
BCALL
Activate
(next rung)
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.
Stage Block
SG
S0
X0
C0
BCALL
All other rungs in stage...
SG
S11
NOTE: Stage Block may come before or
after the location of the BCALL instruction
in the program.
BLK
C0
SG
S10
All rungs in stage...
SG
S11
All other rungs in stage...
BEND
The BCALL may be used in many ways or contexts, so it can be difficult to find the
best usage. Just remember that 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.
DL405 User Manual, 4th Edition, Rev. A
RLL PLUS Stage Programming
7--23
RLL PLUS Instructions
Stage
(SG)
430 440 450
The Stage instructions are used to create
structured RLL PLUS 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.
Stage
S aaa
DL430 Range
DL440 Range
aaa
aaa
aaa
0--577
0--1777
0--1777
S
DL450 Range
The following example is a simple RLL PLUS program. This program utilizes the initial
stage, stage, and jump instruction to create a structured program.
DirectSOFT Display
Handheld Programmer Keystrokes
ISG
ISG
S(SG)
0
STR
X(IN)
0
OUT
Y(OUT)
1
STR
X(IN)
1
SET
S(SG)
2
STR
X(IN)
5
S2
JMP
S(SG)
1
SET
SG
S(SG)
1
S0
X0
Y10
OUT
X1
X5
SG
S1
STR
X(IN)
2
JMP
OUT
Y(OUT)
1
SG
S(SG)
2
STR
X(IN)
6
OUT
Y(OUT)
1
S1
X2
Y11
OUT
SG
RLL PLUS
Stage Programming
Operand Data Type
SG
STR
X(IN)
7
AND
S(SG)
1
JMP
S(SG)
0
0
1
2
S2
X6
Y12
OUT
X7
S1
S0
JMP
DL405 User Manual, 4th Edition, Rev. A
7--24
RLL PLUS Stage Programming
Initial Stage
(ISG)
RLL PLUS
Stage Programming
430 440 450
The Initial Stage instruction is normally used
as the first segment of an RLL PLUS program.
Initial stages will be active when the CPU
enters the run mode allowing for a starting
point in the program. Initial Stages are also
activated by transitional logic, a jump or a
set stage executed from an active stage.
Initial Stages are deactivated one scan after
transitional logic, a jump, or a reset stage
instruction is executed. Multiple Initial
Stages are allowed in a program.
Operand Data Type
Stage
S
ISG
S aaa
DL430 Range
DL440 Range
aaa
aaa
DL450 Range
aaa
0--577
0--1777
0--1777
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.
Jump
(JMP)
430 440 450
The Jump instruction allows the program to
transition from an active stage which
contains the jump instruction to another
which stage is specified in the instruction.
The jump 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.
Operand Data Type
Stage
Not Jump
(NJMP)
430 440 450
S
S aaa
JMP
DL430 Range
DL440 Range
aaa
aaa
aaa
0--577
0--1777
0--1777
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 occur when the input logic is
off. The active stage that contains the Not
Jump will be deactivated 1 scan after the
Not Jump instruction is executed.
Operand Data Type
Stage
S
DL405 User Manual, 4th Edition, Rev. A
DL450 Range
S aaa
NJMP
DL430 Range
DL440 Range
aaa
aaa
DL450 Range
aaa
0--577
0--1777
0--1777
RLL PLUS Stage Programming
7--25
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 Display
ISG
Handheld Programmer Keystrokes
S(SG)
0
X(IN)
1
JMP
S(SG)
1
S1
SG
S(SG)
1
JMP
STR
X(IN)
2
OUT
Y(OUT)
5
STR
X(IN)
7
JMP
S(SG)
2
NOT
JMP
S(SG)
S0
X1
SG
S1
X2
X7
Y5
3
OUT
S2
JMP
RLL PLUS
Stage Programming
ISG
STR
S3
NJMP
Converge Stage
(CV) and Converge
Jump (CVJMP)
X 430 440 450
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
CV
S aaa
S aaa
CVJMP
DL440 Range
aaa
Stage
S
0--1777
DL405 User Manual, 4th Edition, Rev. A
7--26
RLL PLUS Stage Programming
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.
DirectSOFT Display
RLL PLUS
Stage Programming
ISG
Handheld Programmer Keystrokes
ISG
S(SG)
0
STR
X(IN)
0
OUT
Y(OUT)
0
STR
X(IN)
1
Y0
JMP
S(SG)
1
OUT
JMP
S(SG)
1
SG
S(SG)
1
STR
X(IN)
2
JMP
S(SG)
1
1
SHFT
C
V
SHFT
S(SG)
1
0
SHFT
C
V
SHFT
S(SG)
1
1
STR
X(IN)
3
JMP
S(SG)
2
S0
X0
X1
S1
JMP
S10
JMP
SG
S1
X2
CV
CV
Y(OUT)
3
STR
X(IN)
4
JMP
SHFT
C
V
SHFT
SG
S(SG)
2
0
STR
X(IN)
5
JMP
S(SG)
0
S11
X4
SG
OUT
S11
S10
X3
Y3
OUT
S20
CVJMP
S20
X5
0
S0
JMP
DL405 User Manual, 4th Edition, Rev. A
0
RLL PLUS Stage Programming
7--27
The stage block instructions are used to activate a block of stages. The Block Call,
Block, and Block End instructions must be used together.
Block Call
(BCALL)
X 430 440 450
C aaa
BCALL
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
RLL PLUS
Stage Programming
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.
DL440 Range
aaa
Control Relay
Block (BLK)
X 430 440 450
C
0--1777
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 any where else in the program.
Operand Data Type
BLK
C aaa
DL440 Range
aaa
Control Relay
Block End (BEND)
X 430 440 450
C
0--1777
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.
BEND
DL405 User Manual, 4th Edition, Rev. A
7--28
RLL PLUS Stage Programming
RLL PLUS
Stage Programming
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’ll notice that X7
could reset Stage S1, which would
disable the BCALL, thus resetting all
stages within the block.
DirectSOFT Display
SG
SG
Y5
X2
OUT
C0
X6
BLK
SG
BCALL
C0
S10
Y6
X3
OUT
BEND
Handheld Programmer Keystrokes
Stage View in
DirectSOFT
S1
SG
SG
S(SG)
1
STR
X(IN)
2
OUT
Y(OUT)
5
STR
X(IN)
6
SHFT
B
C
A
L
L
SHFT
SHFT
B
L
K
SHFT
C(CR)
0
0
S15
S1
X7
SG
S(SG)
1
STR
X(IN)
3
OUT
Y(OUT)
6
SHFT
B
E
N
SG
S(SG)
1
5
STR
X(IN)
7
RST
S(SG)
1
C(CR)
RST
0
D
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.
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
DL405 User Manual, 4th Edition, Rev. A
SG
S1
J
SG
S2
S
SG
S4
J
SG
S3
J
SG
S5
RLL PLUS Stage Programming
7--29
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. Isn’t a stage really just like a software subroutine?
A. No, it is very different. A subroutine is called by a main program when needed, and
executes just 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.
RLL PLUS
Stage Programming
Q. What does stage programming do that I can’t do with standard 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 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. What are Stage Bits?
A. A stage bit is just 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:
S If the Stage is an initial stage (ISG), it is automatically active at powerup.
S Another stage can execute a Stage JMP instruction naming this stage,
which makes it active upon its next occurrence in the program.
S 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:
S Standard Stages (SG) are automatically inactive at powerup.
S A stage can execute a Stage JMP instruction, resetting its Stage Bit to
0.
S 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.
DL405 User Manual, 4th Edition, Rev. A
7--30
RLL PLUS Stage Programming
RLL PLUS
Stage Programming
Q. Can I have a stage which is active for only one scan?
A. Yes, but this is not the intended use for a stage. Instead, just make a ladder rung
active for 1 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:
S 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.
S 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:
S Use a Stage JMP instruction for a state transition... moving from one
state to another.
S 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.
S Use a Reset Stage 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 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?
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.
DL405 User Manual, 4th Edition, Rev. A