RLL PLUS Stage Programming

In This Chapter. . . .

17

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

72

RLL PLUS Stage Programming

Introduction to Stage Programming

4 4 4
230 240 250

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 RLL PLUS. 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.

RLL PLUS Stage Programming

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: 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

C0 RST C1 Y0 SET

X4

STAGE!

X3

Y2 OUT

Its 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.

RLL PLUS Stage Programming

73

Learning to Draw State Transition Diagrams

Introduction to Process States Those familiar with ladder program execution know 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 a few milliseconds. Inputs Ladder Program Outputs

PLC Scan
1) Read 2) Read 3) Read Execute Execute (etc....) Write Write

RLL PLUS Stage Programming

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 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 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! A 2State Process Consider the simple process shown to the Inputs Outputs 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 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. If youre 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.

74

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
X1

ON

Output equation: Y0 = ON

First, we will translate the state diagram to traditional RLL. Then we will show how easy it is to translate the diagram into a stage programming solution. RLL PLUS Stage Programming RLL Equivalent The RLL solution is shown to the right. It consists of a self-latching control relay, C0. When the On momentary pushbutton (X0) is pressed, output coil C0 turns on and the C0 contact on the second row latches itself on. So, X0 sets the latch C0 on, and it remains on after the X0 contact opens. The motor output Y0 also has power flow, so the motor is now on. When the Off pushbutton (X1) is pressed, it opens the normally-closed X1 contact, which resets the latch. Motor output Y0 turns off when the latch coil C0 goes 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 the PLC only has to scan those rungs when the corresponding stage is active! For now, lets 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
X0

Reset
X1

Latch
C0 OUT

Latch
C0

Output
Y0 OUT

Stage Equivalent

SG S0

OFF State Transition

X0 S1 JMP

SG S1

ON State Output
SP1 Always on 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.

RLL PLUS Stage Programming

75

Lets Compare

Right now, you may be thinking I dont 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 SG and ON states of the state transition OFF State S0 diagram below to the stage program at the S1 X0 right. Now, we challenge anyone to easily identify the same states in the RLL JMP program on the previous page! RLL PLUS Stage Programming
SG S1 SP1

ON State
Y0 OUT S0 JMP

X0
X1

OFF
X1

ON

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 like any other stage! We can change both programs so 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 ON State
X0 X1 C0 OUT Y0 OUT

Powerup in OFF State

ISG S0 X0

Initial Stage
S1 JMP

SG S1 SP1 X1 Y0 OUT S0 JMP

Powerup in ON State
SG S0 X0 S1 JMP ISG S1 SP1

Initial Stage
Y0 OUT S0 JMP

C0

SP0

X1

First Scan

76

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
X1

ON

RLL PLUS Stage Programming

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 Sxxx) reside in the PLCs 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 Functionally Equivalent Ladder

SG S0

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 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.

SG S0

SG S1

SG S2

END

RLL PLUS Stage Programming

77

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

RLL PLUS Stage Programming

S0
SG S0 X0 S1 JMP

S1
SG S0

Equivalent

X0

S0 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. Heres 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.
Executes on next scan after Jmp
S1 Y0 OUT SG S0 X0 S1 JMP

SG S0 X0 S1 JMP SG S1 S1

SG S1

Executes on same scan as Jmp

Y0 OUT

Note: Assume we start with Stage 0 active and stage 1 inactive for both examples.

78

RLL PLUS Stage Programming

Stage Program Example: Toggle On/Off Lamp Controller

A 4State 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 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

Outputs

X0

Ladder Program

Y0

RLL PLUS Stage Programming

Powerup X0

OFF
X0

ON

Output equation: Y0 = ON

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 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
PushON

X0

ISG S0

OFF State
X0 S1 JMP

OFF
PushOFF

ON
SG S1

X0

X0 Output equation: Y0 = ON

PushOn State
X0 S2 JMP

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!

SG S2 SP1

ON State Output
Y0 OUT S3 JMP

X0

SG S3 X0

PushOff State
S0 JMP

RLL PLUS Stage Programming

79

Four Steps to Writing a Stage Program

By now, youve 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. Its 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. RLL PLUS Stage Programming

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.

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 DL230and DL240 CPU. Up to 1024 total stages are available in the DL250 CPUs. 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 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!

710

RLL PLUS Stage Programming

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 push-release cycle will lower the door.

RLL PLUS Stage Programming

In order to identify the inputs and outputs of the system, its 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. Draw the Block Diagram

Up limit switch Raise Lower

Motor

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.

Outputs

To motor: Ladder Program Y1

Raise

Y2

Lower

RLL PLUS Stage Programming

711

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. 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
PushUP

RLL PLUS Stage Programming

X0 Powerup

RAISE

X1

ISG S0 X0

DOWN State
S1 JMP

DOWN

UP
SG S1

PushUP State
X0 S2 JMP

X2

LOWER
X0

PushDOWN

X0

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 motors 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. NOTE: The only special thing about an initial stage (ISG) is that it is automatically active at powerup. Afterwards, it is like any other.

SG S2 SP1

RAISE State
Y1 OUT S3 JMP

X1

SG S3 X0

UP State
S4 JMP

SG S4 X0

PushDOWN State
S5 JMP

SG S5 SP1

LOWER State
Y2 OUT S0 JMP

X2

712

RLL PLUS Stage Programming

Add Safety Light Feature

RLL PLUS Stage Programming

Next we will add a safety light feature to the door opener system. Its 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 will use the set and reset commands.

Safety light

Modify the To control the light bulb, we add an output Inputs 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 Raise

Ladder Program Y2

Lower

Y3

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 becomes inactive, and the light goes out!
Output equations: X0 X0
PushUP

RAISE
X0

Y1 = RAISE Y2 = LOWER Y3 = LIGHT

X1

DOWN

LIGHT

T0

UP

X0 X2

LOWER
X0

PushDOWN

X0

RLL PLUS Stage Programming

713

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 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 doesnt matter! S 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 (thats 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 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 X0

DOWN State
S1 JMP

SG S1 X0

PushUP State
S2 JMP S6 SET

RLL PLUS Stage Programming

SG S2 SP1

RAISE State
Y1 OUT S3 JMP

X1

SG S3 X0

UP State
S4 JMP

SG S4 X0

PushDOWN State
S5 JMP S6 SET

SG S5 SP1

LOWER State
Y2 OUT S0 JMP

X2

SG S6 SP1

LIGHT State
Y3 OUT TMR T0 K1800 T0 S6 RST

714

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.
X0 X0
PushUP

Inputs
Toggle Up limit X1 Down limit X2 Obstruction X3 X0

Outputs
Y1 Raise Lower Light

RLL PLUS Stage Programming

Ladder Y2 Program
Y3

RAISE
X0

X1

DOWN

X3

LIGHT

T0

UP

X0 X2 and X3

LOWER
X0

PushDOWN

X0

Exclusive Transitions

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 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 S0 X2 X3 to Push-UP 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.

RLL PLUS Stage Programming

715

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.
Main Process
XXX

RLL PLUS Stage Programming

= ISG Idle Powerup Initialization Powerup Fill Agitate Rinse Spin

E-Stop and Alarm Monitoring Monitor

Operator Interface Control Recipe

Status

In a typical application, the separate stage sequences above operate as follows: S 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). 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 Control Recipe

Monitor

Set

Status

E-Stop and Alarm Monitoring

716

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. Its easy to choose which ladder rungs are active at powerup by using an initial stage type (ISG).
Stage 0 Stage 1

RLL PLUS Stage Programming

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: 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 the input to the coil must make a 01 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 01 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 01 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.

RLL PLUS Stage Programming

717

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.
Powerup

Ladder Program

Y0

RLL PLUS Stage Programming

ISG S0 Supervisor

OFF State
X0 S1 JMP

Supervisor Process

Powerup

X0

PushON

X0

SG S1 X0

PushOn State
S2 JMP

OFF

Main Process

ON
SG S2 SP1

X0

PushOFF

X0

ON State
Y0 OUT S3 JMP

New stage programming students will typically try to place the counter inside one 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! Note that both the Supervisor stage and the OFF stage are initial stages. The supervisor stage remains active indefinitely. Stage Counter

X0

SG S3 X0

PushOff State
S0 JMP

ISG S4 S1

Supervisor State
SGCNT K5000 CT0

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.

718

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. Its 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 powerflow comes from the rung above. So, Y0 status will be the same as Y1 (is not correct).

SG S0 SP1 Y0 OUT

SG S1

Unconditional Output
Y0 OUT X0 Y1 OUT

RLL PLUS Stage Programming

SG S2 X0 Y1 OUT Y0 OUT

Power Flow Transition Technique

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. S0
X0

S1

SG S0 X0 S1 JMP

SG S0

All other rungs in stage...

X0

Equivalent
SG S1 SG S1

Power flow transition

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.

RLL PLUS Stage Programming

719

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 S2 S0 S1
X0

S3

SG S1 X0

PushOn State

RLL PLUS Stage Programming

S2 JMP

Process B

S4

S5

S4 JMP

Converging Processes

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 77). 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.
Process A S1 S2 S5 Process B S3 S4 S6

= Convergence Stage

Convergence Stages (CV) 5 4 4

230 240 250

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

720

RLL PLUS Stage Programming

RLL PLUS Stage Programming

Convergence Jump Recall the last convergence stage only has power flow when all CV stages in the (CVJMP) group are active. To complement the 5 4 4 convergence stage, we need a new jump 230 240 250 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

The following summarizes the requirements in the use of convergence stages, including some tips for their effective application: 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.

S S S

S S

S S

RLL PLUS Stage Programming

721

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. 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

Stage Blocks (BLK, BEND) 5 4 4

230 240 250

RLL PLUS Stage Programming

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 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 the block instruction has a reference S1 value field (set to C0 in the example). All other rungs in stage... The block instruction borrows or uses a control relay contact number, so that other Block End parts of the program can control the block. Instruction BEND Any control relay number (such as 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.

722

RLL PLUS Stage Programming

Block Call (BCALL) 5 4 4

230 240 250

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

RLL PLUS Stage Programming

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.
SG S0 X0 C0 BCALL SG S10

Stage Block
BLK C0

All other rungs in stage...

SG S11

All rungs in stage...

SG S11

All other rungs in stage... NOTE: Stage Block may come before or after the location of the BCALL instruction in the program.
BEND

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.

RLL PLUS Stage Programming

723

RLL PLUS Instructions

Stage (SG) 4 4 4
230 240 250

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.
Operand Data Type DL230 Range aaa Stage S 0377 DL240 Range aaa 0777

SG S aaa

RLL PLUS Stage Programming

DL250 Range aaa 01777

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 ISG Handheld Programmer Keystrokes S(SG) X(IN) Y(OUT) X(IN) S(SG) X(IN) S(SG) S(SG) X(IN) Y(OUT) S(SG) X(IN) Y(OUT) X(IN) S(SG) S(SG) 0 0 1 1 2 5 1 1 2 1 2 6 1 7 1 0 ENT ENT 0 ENT ENT ENT ENT ENT ENT 1 ENT ENT 2 ENT ENT ENT ENT ENT

ISG

S0

STR OUT STR

X0

Y10 OUT

SET STR JMP SG STR OUT SG

X1

S2 SET

X5

S1 JMP

SG

S1

STR OUT STR

X2

Y11 OUT

AND JMP

SG

S2

X6

Y12 OUT

X7

S1

S0 JMP

724

RLL PLUS Stage Programming

Initial Stage (ISG) 4 4 4

230 240 250

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 DL230 Range aaa Stage S 0377 DL240 Range aaa 0777

ISG S aaa

RLL PLUS Stage Programming

DL250 Range aaa 01777

Jump (JMP) 4 4 4
230 240 250

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 DL230 Range aaa Stage S 0377 DL240 Range aaa 0777

S aaa JMP

DL250 Range aaa 01777

Not Jump (NJMP) 4 4 4

230 240 250

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 DL230 Range aaa Stage S 0377 DL240 Range aaa 0777

S aaa NJMP

DL250 Range aaa 01777

RLL PLUS Stage Programming

725

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) X(IN) S(SG) S(SG) X(IN) Y(OUT) X(IN) S(SG) N 3 JMP ENT 0 1 1 1 2 5 7 2 ENT ENT ENT ENT ENT

ISG

S0 S1 JMP

STR JMP SG STR OUT

X1

RLL PLUS Stage Programming

ENT ENT ENT

SG

S1

STR JMP

X2

Y5 OUT S2 JMP S3 NJMP

SHFT S(SG)

X7

Converge Stage (CV) and Converge Jump (CVJMP) 5 4 4

230 240 250

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 DL240 Range aaa Stage S 0777 DL250 Range aaa 01777

CV S aaa

S aaa CVJMP

726

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 ISG STR Handheld Programmer Keystrokes S(SG) X(IN) Y(OUT) X(IN) S(SG) S(SG) S(SG) X(IN) S(SG) C C V V X(IN) Y(OUT) X(IN) C V S(SG) X(IN) S(SG) 3 3 4 SHFT 2 5 0 0 0 0 1 1 1 1 2 1 ENT ENT ENT ENT ENT 0 ENT ENT 1 S(SG) S(SG) ENT ENT ENT JMP 0 ENT ENT S(SG) ENT 2 0 ENT ENT 1 1 0 1 ENT ENT ENT

ISG

S0

OUT STR

RLL PLUS Stage Programming

X0

Y0 OUT S1 JMP S10 JMP

JMP JMP SG

X1

STR JMP SHFT SHFT

SG

S1

STR OUT

X2

S11 JMP

STR SHFT SG

CV

S10

STR JMP

CV

S11

X3

Y3 OUT S20 CVJMP

X4

SG

S20

X5

S0 JMP

RLL PLUS Stage Programming

727

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) 5 4 4
230 240 250

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.

C aaa BCALL

RLL PLUS Stage Programming

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 DL240 Range aaa Control Relay C 0777 DL250 Range aaa 01777

Block (BLK) 5 4 4
230 240 250

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 DL240 Range aaa Control Relay C 0777 DL250 Range aaa 01777

BLK C aaa

Block End (BEND) 5 4 4

230 240 250

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.

BEND

728

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 will notice that X7 could reset Stage S1, which would disable the BCALL, thus resetting all stages within the block.
Handheld Programmer Keystrokes SG STR OUT STR SHFT SHFT SG STR OUT SHFT SG STR RST B B B S(SG) X(IN) Y(OUT) X(IN) C L S(SG) X(IN) Y(OUT) E S(SG) X(IN) S(SG) 1 2 5 6 A K 1 3 6 N 1 7 1 0 ENT ENT D 5 ENT ENT ENT ENT ENT ENT ENT ENT L L C(CR) ENT 0

DirectSOFT Display

SG S1 X2 Y5 OUT X6 C0 BCALL

BLK C0 SG S10 X3 Y6 OUT BEND SG S15 X7 S1 RST

C(CR) ENT

ENT

Stage View in DirectSOFT

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.
Reference to a Stage Transition Logic Output J Jump S R Set Stage Reset Stage

SG

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 SG S1 SG S2 SG S3 SG S4 SG S5

RLL PLUS Stage Programming

729

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 cannot 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. Isnt 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 CPUs 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.

RLL PLUS Stage Programming

730

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, 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. Isnt a Stage JMP 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 stages 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 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 its 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.

RLL PLUS Stage Programming