As kind of a newbie in plc programing, though I have some experience in PC based automation control, it’s still many thing I learned from plc programming.
I’ll write some articles to record what I’ve learned from plc.
What’s the purpose when using function block ?
Basically, it’s all because we’re lazy, we don’t want to write those similar piece of code again and again.
Or we can say that it is for modularization, componentization, because of the increasingly complex needs.
Example of simple function block
In here, I’ll describe some very simple function block with mitsubishi Fx series plc.
The control of pneumatic cylinder
Picture from wikipedia.
Originally, to control a pneumatic cylinder, depends on it’s type, we need a control flag, one or more outputs, some timers to make sure it’s state, some parameters to indicate the time, like this:
Thankfully we got function block, we can encapsulate the boring part inside the box.
| // FbCylinder0X1Y | |
| // no limit sensor | |
| // 1 output | |
| // ex: | |
| // cySt1Clamp(gCySt1ClampAct, wSt1ClampOnT, wSt1ClampOffT, ySt1Clamp); | |
| oDevice := iAct; | |
| tmrOnDelay(IN := oDevice, PT := INT_TO_TIME(iOnDelay*100)); | |
| oOn := tmrOnDelay.Q; | |
| tmrOffDelay(IN := NOT oDevice, PT := INT_TO_TIME(iOffDelay*100)); | |
| oOff := tmrOffDelay.Q; |
| // FbCylinder1x1y | |
| // 1 limit sensor | |
| // 1 output | |
| // ex: | |
| // cySt1GoDown(gCySt1GoDownAct, xSt1Down, wSt1OnT, wSt1OffT, ySt1GoDown); | |
| oDevice := iAct; | |
| tmrOn(IN := oDevice AND NOT iLimit1, PT:= INT_TO_TIME(iOnTO*100)); | |
| tmrOff(IN := NOT oDevice AND iLimit1, PT:= INT_TO_TIME(iOffTO*100)); | |
| RST(iRst AND oErr, oErr); | |
| SET(tmrOn.Q OR tmrOff.Q, oErr); | |
| oOn := tmrOnDelay.Q; | |
| oOff := tmrOffDelay.Q; | |
| IF oErr THEN | |
| IF tmrOff.Q THEN | |
| oErrId := 20; | |
| ELSIF tmrOn.Q THEN | |
| oErrId := 10; | |
| END_IF; | |
| ELSE | |
| oErrId := 0; | |
| END_IF; |
Usage
With Gx Works2:
With Gx Works3 FBD:
With ST language:
The control of vibratory bowl feeder
In the simplest situation to feed individual component parts for assembly on industrial production line, it going to combine bowl feeder with linear feeder.
Basically it’ll have a sensor to indicate if the output of bowl feeder is full or not, a sensor to indicate the output of linear feeder, if it’s on, the next station can pick workpiece from here.
| // Vibratory Bowl with Linear Feeder | |
| // Lf means Linear Feeder | |
| // | |
| // 2 input x, | |
| // iArrived => sensor in linear feeder | |
| // iFull => sensor in vibratory bowl | |
| // | |
| // 2 output | |
| // oLf => linear feeder output y | |
| // oVibratoryBowl => vibratory bowl output y | |
| // | |
| // 4 parameter | |
| // iLfTO => time out of linear feeder | |
| // iArrivedOnT => arrived time, then we can pick in next station | |
| // iFullOnT => on to turn off the bowl feeder | |
| // iFullOffT => on to turn on the bowl feeder | |
| oLf := iAct; | |
| tmrLfTO( | |
| IN := iAct AND NOT iArrived, | |
| PT := INT_TO_TIME(iLfTO*100)); | |
| tmrArrivedOn( | |
| IN := iAct AND iArrived, | |
| PT := INT_TO_TIME(iArrivedOnT*100)); | |
| oCanPick := iAct AND tmrArrivedOn.Q; | |
| tmrFullOn( | |
| IN := iAct AND iFull, | |
| PT := INT_TO_TIME(iFullOnT*100)); | |
| tmrFullOff( | |
| IN := iAct AND NOT iFull, | |
| PT := INT_TO_TIME(iFullOffT*100)); | |
| IF iAct THEN | |
| IF LDP(TRUE, tmrFullOff.Q) THEN | |
| SET(TRUE, oVibratoryBowl); | |
| END_IF; | |
| IF LDP(TRUE, tmrFullOn.Q) THEN | |
| RST(TRUE, oVibratoryBowl); | |
| END_IF; | |
| ELSE | |
| RST(TRUE, oVibratoryBowl); | |
| END_IF; | |
| tmrNeedSupply( | |
| IN := iAct AND oVibratoryBowl, | |
| PT := INT_TO_TIME(iSupplyTO*100)); | |
| oNeedSupply := iAct AND tmrNeedSupply.Q AND (NOT tmrFullOn.Q); | |
| oLfTO := tmrLfTO.Q; |
I prefer to write with ST language, the additional benefits of it is we can go further for the creation process, like use some template to auto generate those codes, then we just need to focus on the control flow!
Written with StackEdit.
