Do-more H2 (Micro Modular PLC) Videos

Hide Transcript

View Transcript

Ladder programming is ideal for taking lots

of inputs and using those inputs to control lots of outputs. Ladder logic can also be used to manage sequences

of events, but it does involve some additional interlocking, control bits, and housekeeping

logic. Stage programming doesnít replace ladder

coding, it makes it easier to use ladder logic to control sequences of events. Letís look at a side by side example comparing

the two methods. Picture a drill head mounted on a carriage. We want the carriage to move out to a fixed

location, the drill to move down and drill a single hole, the drill to retract, and the

carriage to return ëhomeí. Hereís how you might do that in ladder ñ

note that this is simplified for example purposes and is NOT intended to be a fully implemented

or tested code set. Weíll run this in the simulator over here

so we can follow along. Letís turn that on Ö put it in run mode

Ö and letís turn our status on se we can see all of the bits. On Rung 1 we make sure the Carriage is pulled

back in and that the Drill position is up. Weíll simulate that by punching X2 and X4. OK, our system is ready to go and weíll accept

the start button from the user. When the user hits the start button - which

is our X1 input ñ we turn on the move out interlock. That tells the rest of the system that the

carriage is moving out. And we turn on the motors so the carriage

starts moving. When the carriage starts moving this IN limit

switch is going to release. So weíll do that. And that moves us down onto this rung. Rung number 2. Now this rung is enabled with this interlock

bit until weíre waiting until the carriage hits the OUT limit switch. When that happens, X3 gets set, we turn off

the motor moving the carriage out, We turn off this rung, We enable the interlock to

the next rung, and we turn on the Drill Down Motor. Now all future scans will ignore this rung,

and weíll come down and run this one. So now the drill is moving down, which will

release the UP Limit Switch, and when it hits the DOWN limit switch, X5, It stops the drill

from moving down, turns off this rung, turns on the drill moving up and enables the next

rung with this interlock. As the drill starts moving up, the down limit

switch will turn off, and eventually we will hit the upper limit switch, X4. When that happens, we stop the Drill Up Motor,

we turn off this rung, we turn on the motor that moves the carriage back to the home position,

and we turn on the next rung with this interlock. As the carriage moves back in, it will release

the OUT limit Switch, and weíll move down to the next rung. Now only this rung is enabled with this interlock

bit. And it is simply waiting for the carriage

to come all the way back in. When that happens, it turns off the carriage

motor, and it turns off the MoveBack In interlock. And of course by now the user would have let

go of the button, hopefully Ö And we are right back to the beginning of

the ladder logic where both limit switches are set and we are waiting for the user to

press the button. Weíll, thatís not too bad, especially when

you give each control bit a good nickname like you see here. Now letís do the exact same thing in stage

programming ñ with one exception. The Stage Program code is in its own code

block called ìDrill_1.î Iíve also made multiple copies of this for something we are

going to do later. Drill_1 is enabled back in main. On the first scan, we enable that drilling

routine, and it runs continuously until the PLC is turned off. So we are just going to focus on Drill_1 so

we can do a side by side comparison with the Ladder Logic we just saw. Weíre going to run it in our simulator, so

letís turn him on, and letís turn on the status bits so we can see whatís going on. The first rung is just a comment, so you can

ignore that. The second rung is our first stage. As you can see from the status bits, this

stage is enabled. The cool thing about this is - over here in

program view, if you open up the program code block ñ you can see exactly which stage you

are in. In stage 0 ñ just like the ladder code ñ

weíre waiting for the motor carriage to be back in and the drill to be up. Letís go ahead and force that by turning

on those bits. When that happens, Stage 0 transitions to

stage 1. So Stage 0 rungs are no longer run, and every

time we come into this code block, we only run the stage 1 ladder code. In Stage 1, we are waiting for the user to

press the start button. Letís do that. Iím going to press it and release it. What that did, is it started the motor to

move the carriage out. As that starts to move, the IN limit switch

is going to release. And eventually it hits the OUT limit switch

at X3. When that happens, we turn off the motor,

and we transition to stage 2. Now these rungs will no longer be run, and

the stage 2 rungs WILL be run. And again, you can see here and here which

stage we are in. In stage 2, we unconditionally enable the

Drill Down motor, which is going to release the UP limit switch, and eventually hit the

down limit switch. When that happens, we turn off that motor,

and transition to Stage 3. In Stage 3, we unconditionally turn on the

Drill Up Motor, which is going to release the drill down limit switch, and eventually

hit the Up limit switch, X4. When that happens, we turn off the motor,

and we transition down to Stage 4. In stage 4, we unconditionally turn on the

motor that pulls the carriage back in Ö which is going to release the OUT limit switch,

and eventually hit the IN switch. When that happens, we turn off the motor,

and we jump back to Stage 1. Letís go up there and look. In stage 1, we wait for the user to press

the button, and we start the sequence all over again. We didnít need to go back to stage 0 because

we know the motor is in and up. So we can go straight to Stage 1 and wait

for the user to press the start button again. As you can see, both ladder and stage are

very similar. But with stage we didnít have to create and

manage a bunch of interlock bits and logic ñ stage did it for us. And hereís a real big advantage of using

stage: Suppose we have a number of these drilling heads. With Stage, I can simply copy this entire

code block and paste it into another drilling code block like I did here: Hereís Drill_1

and Drill_2 Ö Look, this code is identical to the code we just looked at. Now, of course, in this new routine all of

your motors and limit switches would change, but what Stage saves us is, having to create

a whole new set of interlock logic and interlock control bits. We get to reuse these S-bits because they

donít interfere with the S-Bits in the other code block. So you can see while I have S0 through S4

here, and S0 through S4 here, and S0 through S4 here, none of these interfere with each

other. These S-Bits are unique to this code block. And thatís where stage saves you a lot of

time and headache when you are setting up sequences of events. With Ladder you would have to create a whole

new set of control bits for each code block you create. And of course, the other cool thing is if

multiple of these heads are running, you can see what stage each head is head is in, in

real time as the program runs. Thatís really handy when you are trying to

figure out what is going on. Not having to worry about all of these control

bits and interlock logic, is especially helpful when you are trying to control sequences of

sequences. Imagine having to keep up with all of THOSE

interlock bits. So again, you can use stage or ladder to manage

sequences. Stage just makes handling sequences easier

when creating the sequencing code, when debugging the sequencing code, and when maintaining

the sequencing code. A word of caution, though Ö make sure you

fully understand ladder BEFORE trying to use Stage. Stage doesnít replace ladder, it just helps

manage it. Well, that should be enough to get you going. Please send us any comments or suggestions

you may have. We appreciate the feedback. Spend Less. Do-more. From Automation Direct.