• 15. LADDER LOGIC FUNCTIONS


  •   
  • FileName: plc_function.pdf [read-online]
    • Abstract: MVM(value,mask,destination) - moves a value to a memory location, but with a mask to select ... MVM function is very useful for applications where individual binary bits are to be manipulated, but ...

Download the ebook

261
15. LADDER LOGIC FUNCTIONS
Topics:
• Functions for data handling, mathematics, conversions, array operations, statis-
tics, comparison and Boolean operations.
• Design examples
Objectives:
• To understand basic functions that allow calculations and comparisons
• To understand array functions using memory files
15.1 INTRODUCTION
Ladder logic input contacts and output coils allow simple logical decisions. Functions extend
basic ladder logic to allow other types of control. For example, the addition of timers and counters
allowed event based control. A longer list of functions is shown in Figure 201. Combinatorial Logic
and Event functions have already been covered. This chapter will discuss Data Handling and Numerical
Logic. The next chapter will cover Lists and Program Control and some of the Input and Output func-
tions. Remaining functions will be discussed in later chapters.
262
Combinatorial Logic
- relay contacts and coils
Events
- timer instructions
- counter instructions
Data Handling
- moves
- mathematics
- conversions
Numerical Logic
- boolean operations
- comparisons
Lists
- shift registers/stacks
- sequencers
Program Control
- branching/looping
- immediate inputs/outputs
- fault/interrupt detection
Input and Output
- PID
- communications
- high speed counters
- ASCII string functions
Figure 201 Basic PLC Function Categories
Most of the functions will use PLC memory locations to get values, store values and track func-
tion status. Most function will normally become active when the input is true. But, some functions, such
as TOF timers, can remain active when the input is off. Other functions will only operate when the
input goes from false to true, this is known as positive edge triggered. Consider a counter that only
counts when the input goes from false to true, the length of time the input is true does not change the
function behavior. A negative edge triggered function would be triggered when the input goes from true
to false. Most functions are not edge triggered: unless stated assume functions are not edge triggered.
NOTE: I do not draw functions exactly as they appear in manuals and programming soft-
ware. This helps save space and makes the instructions somewhat easier to read. All of
the necessary information is given.
263
15.2 DATA HANDLING
15.2.1 Move Functions
There are two basic types of move functions;
MOV(value,destination) - moves a value to a memory location
MVM(value,mask,destination) - moves a value to a memory location, but with a mask to select
specific bits.
The simple MOV will take a value from one location in memory and place it in another mem-
ory location. Examples of the basic MOV are given in Figure 202. When A is true the MOV function
moves a floating point number from the source to the destination address. The data in the source
address is left unchanged. When B is true the floating point number in the source will be converted to
an integer and stored in the destination address in integer memory. The floating point number will be
rounded up or down to the nearest integer. When C is true the integer value of 123 will be placed in the
integer file test_int.
A MOV
Source test_real_1
Destination test_real_2
B MOV
Source test_real_1
Destination test_int
C MOV
Source 123
Destination test_int
NOTE: when a function changes a value, except for inputs and outputs, the value is
changed immediately. Consider Figure 202, if A, B and C are all true, then the value
in test_real_2 will change before the next instruction starts. This is different than
the input and output scans that only happen before and after the logic scan.
Figure 202 Examples of the MOV Function
A more complex example of move functions is given in Figure 203. When A becomes true the
first move statement will move the value of 130 into int_0. And, the second move statement will move
the value of -9385 from int_1 to int_2. (Note: The number is shown as negative because we are using 2s
compliment.) For the simple MOVs the binary values are not needed, but for the MVM statement the
264
binary values are essential. The statement moves the binary bits from int_3 to int_5, but only those bits
that are also on in the mask int_4, other bits in the destination will be left untouched. Notice that the
first bit int_5.0 is true in the destination address before and after, but it is not true in the mask. The
MVM function is very useful for applications where individual binary bits are to be manipulated, but
they are less useful when dealing with actual number values.
A
MOV
source 130
dest int_0
MOV
source int_1
dest int_2
MVM
source int_3
mask int_4
dest int_5
MVM
source int_3
mask int_4
dest int_6
before after
binary decimal binary decimal
int_0 0000000000000000 0 0000000010000010 130
int_1 1101101101010111 -9385 1101101101010111 -9385
int_2 1000000000000000 -32768 1101101101010111 -9385
int_3 0101100010111011 22715 becomes 0101100010111011 22715
int_4 0010101010101010 10922 0010101010101010 10922
int_5 0000000000000001 1 0000100010101011 2219
int_6 1101110111111111 1101110111111111
NOTE: the concept of a mask is very useful, and it will be used in other functions.
Masks allow instructions to change a couple of bits in a binary number without hav-
ing to change the entire number. You might want to do this when you are using bits in
a number to represent states, modes, status, etc.
Figure 203 Example of the MOV and MVM Statement with Binary Values
265
15.2.2 Mathematical Functions
Mathematical functions will retrieve one or more values, perform an operation and store the
result in memory. Figure 204 shows an ADD function that will retrieve values from int_1 and real_1,
convert them both to the type of the destination address, add the floating point numbers, and store the
result in real_2. The function has two sources labelled source A and source B. In the case of ADD func-
tions the sequence can change, but this is not true for other operations such as subtraction and division.
A list of other simple arithmetic function follows. Some of the functions, such as the negative function
are unary, so there is only one source.
A
ADD
source A int_1
source B real_1
destination real_2
ADD(value,value,destination) - add two values
SUB(value,value,destination) - subtract
MUL(value,value,destination) - multiply
DIV(value,value,destination) - divide
NEG(value,destination) - reverse sign from positive/negative
CLR(value) - clear the memory location
NOTE: To save space the function types are shown in the shortened notation above.
For example the function ADD(value, value, destination) requires two source val-
ues and will store it in a destination. It will use this notation in a few places to
reduce the bulk of the function descriptions.
Figure 204 Arithmetic Functions
An application of the arithmetic function is shown in Figure 205. Most of the operations provide
the results we would expect. The second ADD function retrieves a value from int_3, adds 1 and over-
writes the source - this is normally known as an increment operation. The first DIV statement divides
the integer 25 by 10, the result is rounded to the nearest integer, in this case 3, and the result is stored in
int_6. The NEG instruction takes the new value of -10, not the original value of 0, from int_4 inverts the
sign and stores it in int_7.
266
ADD
source A int_0
source B int_1
dest. int_2
ADD addr. before after
source A 1
source B int_3 int_0 10 10
dest. int_3 int_1 25 25
int_2 0 35
SUB int_3 0 1
source A int_1 int_4 0 -10
source B int_2 int_5 0 250
dest. int_4 int_6 0 3
MULT int_7 0 10
source A int_0 int_8 100 0
source B int_1
dest. int_5 flt_0 10.0 10.0
flt_1 25.0 25.0
DIV flt_2 0 2.5
source A int_1 flt_3 0 2.5
source B int_0
dest. int_6
NEG
source A int_4 Note: recall, integer
dest. int_7 values are limited
to ranges between -
CLR 32768 and 32767,
dest. int_8 and there are no
DIV fractions.
source A flt_1
source B flt_0
dest. flt_2
DIV
source A int_1
source B int_0
dest. flt_3
Figure 205 Arithmetic Function Example
A list of more advanced functions are given in Figure 206. This list includes basic trigonometry
functions, exponents, logarithms and a square root function. The last function CPT will accept an
expression and perform a complex calculation.
267
ACS(value,destination) - inverse cosine
COS(value,destination) - cosine
ASN(value,destination) - inverse sine
SIN(value,destination) - sine
ATN(value,destination) - inverse tangent
TAN(value,destination) - tangent
XPY(value,value,destination) - X to the power of Y
LN(value,destination) - natural log
LOG(value,destination) - base 10 log
SQR(value,destination) - square root
CPT(destination,expression) - does a calculation
Figure 206 Advanced Mathematical Functions
Figure 207 shows an example where an equation has been converted to ladder logic. The first
step in the conversion is to convert the variables in the equation to unused memory locations in the
PLC. The equation can then be converted using the most nested calculations in the equation, such as the
LN function. In this case the results of the LN function are stored in another memory location, to be
recalled later. The other operations are implemented in a similar manner. (Note: This equation could
have been implemented in other forms, using fewer memory locations.)
268
given
C
A = ln B + e acos ( D )
LN
Source B
Dest. temp_1
XPY
SourceA 2.718
SourceB C
Dest temp_2
ACS
SourceA D
Dest. temp_3
MUL
SourceA temp_2
SourceB temp_3
Dest temp_4
ADD
SourceA temp_1
SourceB temp_4
Dest temp_5
SQR
SourceA temp_5
Dest. A
Figure 207 An Equation in Ladder Logic
The same equation in Figure 207 could have been implemented with a CPT function as shown
in Figure 208. The equation uses the same memory locations chosen in Figure 207. The expression is
typed directly into the PLC programming software.
go CPT
Dest. A
Expression
SQR(LN(B)+XPY(2.718,C)*ACS(D))
269
Figure 208 Calculations with a Compute Function
Math functions can result in status flags such as overflow, carry, etc. care must be taken to avoid
problems such as overflows. These problems are less common when using floating point numbers. Inte-
gers are more prone to these problems because they are limited to the range.
15.2.3 Conversions
Ladder logic conversion functions are listed in Figure 209. The example function will retrieve a
BCD number from the D type (BCD) memory and convert it to a floating point number that will be
stored in F8:2. The other function will convert from 2s compliment binary to BCD, and between radi-
ans and degrees.
A FRD
Source A D10:5
Dest. F8:2
TOD(value,destination) - convert from BCD to 2s compliment
FRD(value,destination) - convert from 2s compliment to BCD
DEG(value,destination) - convert from radians to degrees
RAD(value,destination) - convert from degrees to radians
Figure 209 Conversion Functions
Examples of the conversion functions are given in Figure 210. The functions load in a source
value, do the conversion, and store the results. The TOD conversion to BCD could result in an overflow
error.
270
FRD
Source bcd_1
Dest. int_0
TOD
Source int_1
Dest. bcd_0
DEG
Source real_0
Dest. real_2
RAD
Source real_1
Dest. real_3
Addr. Before after
int_0 0 1793
int_1 548 548
real_0 3.141 3.141
real_1 45 45
real_2 0 180
real_3 0 0.785
bcd_0 0000 0000 0000 0000 0000 0101 0100 1000 these are shown in
bcd_1 0001 0111 1001 0011 0001 0111 1001 0011 binary BCD form
Figure 210 Conversion Example
15.2.4 Array Data Functions
Arrays allow us to store multiple data values. In a PLC this will be a sequential series of num-
bers in integer, floating point, or other memory. For example, assume we are measuring and storing the
weight of a bag of chips in floating point memory starting at weight[0]. We could read a weight value
every 10 minutes, and once every hour find the average of the six weights. This section will focus on
techniques that manipulate groups of data organized in arrays, also called blocks in the manuals.
15.2.4.1 - Statistics
Functions are available that allow statistical calculations. These functions are listed in Figure
211. When A becomes true the average (AVE) conversion will start at memory location weight[0] and
average a total of 4 values. The control word weight_control is used to keep track of the progress of the
271
operation, and to determine when the operation is complete. This operation, and the others, are edge
triggered. The operation may require multiple scans to be completed. When the operation is done the
average will be stored in weight_avg and the weight_control.DN bit will be turned on.
A AVE
File weight[0]
Dest weight_avg
Control weight_control
length 4
position 0
AVE(start value,destination,control,length) - average of values
STD(start value,destination,control,length) - standard deviation of values
SRT(start value,control,length) - sort a list of values
Figure 211 Statistic Functions
Examples of the statistical functions are given in Figure 212 for an array of data that starts at
weight[0] and is 4 values long. When done the average will be stored in weight_avg, and the standard
deviation will be stored in weight_std. The set of values will also be sorted in ascending order from
weight[0] to weight[3]. Each of the function should have their own control memory to prevent overlap.
It is not a good idea to activate the sort and the other calculations at the same time, as the sort may move
values during the calculation, resulting in incorrect calculations.
272
A AVE
File weight[0]
Dest weight_avg
Control c_1
length 4
position 0
B STD
File weight[0]
Dest weight_std
Control c_2
length 4
position 0
C SRT
File weight[0]
Control c_3
Addr. before after A after B after C length 4
position 0
weight[0] 3 3 3 1
weight[1] 1 1 1 2
weight[2] 2 2 2 3
weight[3] 4 4 4 4
weight_avg 0 2.5 2.5 2.5
weight_std 0 0 1.29 1.29
Figure 212 Statistical Calculations
ASIDE: These function will allow a real-time calculation of SPC data for con-
trol limits, etc. The only PLC function missing is a random function that
would allow random sample times.
15.2.4.2 - Block Operations
A basic block function is shown in Figure 213. This COP (copy) function will copy an array of
10 values starting at n[50] to n[40]. The FAL function will perform mathematical operations using an
expression string, and the FSC function will allow two arrays to be compared using an expression. The
FLL function will fill a block of memory with a single value.
273
A
COP
Source n[50]
Dest n[40]
Length 10
COP(start value,destination,length) - copies a block of values
FAL(control,length,mode,destination,expression) - will perform basic math
operations to multiple values.
FSC(control,length,mode,expression) - will do a comparison to multiple values
FLL(value,destination,length) - copies a single value to a block of memory
Figure 213 Block Operation Functions
Figure 214 shows an example of the FAL function with different addressing modes. The first
FAL function will do the following calculations n[5]=n[0]+5, n[6]=n[1]+5, n[7]=n[2]+5,
n[7]=n[3]+5, n[9]=n[4]+5. The second FAL statement will be n[5]=n[0]+5, n[6]=n[0]+5,
n[7]=n[0]+5, n[7]=n[0]+5, n[9]=n[0]+5. With a mode of 2 the instruction will do two of the calcula-
tions when there is a positive edge from B (i.e., a transition from false to true). The result of the last
FAL statement will be n[5]=n[0]+5, n[5]=n[1]+5, n[5]=n[2]+5, n[5]=n[3]+5, n[5]=n[4]+5. The
last operation would seem to be useless, but notice that the mode is incremental. This mode will do one
calculation for each positive transition of C. The all mode will perform all five calculations in a single
scan whenever there is a positive edge on the input. It is also possible to put in a number that will indi-
cate the number of calculations per scan. The calculation time can be long for large arrays and trying to
do all of the calculations in one scan may lead to a watchdog time-out fault.
274
FAL
A Control c_0
length 5 array to array
position 0
Mode all
Destination n[c_0.POS + 5]
Expression n[c_0.POS] + 5
FAL
B Control c_1
length 5 element to array
position 0 array to element
Mode 2
Destination n[c_1.POS + 5]
Expression n[0] + 5
FAL
C Control c_2
length 5
position 0 array to element
Mode incremental
Destination n[5]
Expression n[c_2.POS] + 5
Figure 214 File Algebra Example
15.3 LOGICAL FUNCTIONS
15.3.1 Comparison of Values
Comparison functions are shown in Figure 215. Previous function blocks were outputs, these
replace input contacts. The example shows an EQU (equal) function that compares two floating point
numbers. If the numbers are equal, the output bit light is true, otherwise it is false. Other types of equal-
ity functions are also listed.
275
light
EQU
A
B
EQU(value,value) - equal
NEQ(value,value) - not equal
LES(value,value) - less than
LEQ(value,value) - less than or equal
GRT(value,value) - greater than
GEQ(value,value) - greater than or equal
CMP(expression) - compares two values for equality
MEQ(value,mask,threshold) - compare for equality using a mask
LIM(low limit,value,high limit) - check for a value between limits
Figure 215 Comparison Functions
The example in Figure 216 shows the six basic comparison functions. To the right of the figure
are examples of the comparison operations.
O_0 O_0=0
EQU O_1=1
A int_3 int_3=5 O_2=0
B int_2 int_2=3 O_3=0
O_1 O_4=1
NEQ O_5=1
A int_3
B int_2
O_2
LES O_0=1
A int_3 O_1=0
B int_2 int_3=3 O_2=0
O_3 int_2=3 O_3=1
LEQ O_4=0
A int_3 O_5=1
B int_2
O_4
GRT
O_0=0
A int_3
O_1=1
B int_2
int_3=1 O_2=1
O_5 int_2=3 O_3=1
GEQ
A int_3 O_4=0
B int_2 O_5=0
Figure 216 Comparison Function Examples
276
The ladder logic in Figure 216 is recreated in Figure 217 with the CMP function that allows text
expressions.
O_0
CMP
expression
int_3 = int_2
O_1
CMP
expression
int_3 int_2
O_2
CMP
expression
int_3 < int_2
O_3
CMP
expression
int_3 int_2
O_5
CMP
expression
int_3 >= int_2
Figure 217 Equivalent Statements Using CMP Statements
Expressions can also be used to do more complex comparisons, as shown in Figure 218. The
expression will determine if B is between A and C.
X
CMP
expression
(B > A) & (B < C)
Figure 218 A More Complex Comparison Expression
The LIM and MEQ functions are shown in Figure 219. The first three functions will compare a
test value to high and low limits. If the high limit is above the low limit and the test value is between or
equal to one limit, then it will be true. If the low limit is above the high limit then the function is only
true for test values outside the range. The masked equal will compare the bits of two numbers, but only
those bits that are true in the mask.
277
LIM
low limit int_0 int_5.0
test value int_1
high limit int_2
LIM
low limit int_2 int_5.1
test value int_1
high limit int_0
LIM
low limit int_2 int_5.2
test value int_3
high limit int_0
MEQ
source int_0 int_5.3
mask int_1
compare int_2
MEQ
source int_0 int_5.4
mask int_1
compare int_4
Addr. before (decimal) before (binary) after (binary)
int_0 1 0000000000000001 0000000000000001
int_1 5 0000000000000101 0000000000000101
int_2 11 0000000000001011 0000000000001011
int_3 15 0000000000001111 0000000000001111
int_4 0000000000001000 0000000000001000
int_5 0 0000000000000000 0000000000001101
Figure 219 Complex Comparison Functions
Figure 220 shows a numberline that helps determine when the LIM function will be true.
278
high limit low limit
low limit high limit
Figure 220 A Number Line for the LIM Function
File to file comparisons are also permitted using the FSC instruction shown in Figure 221. The
instruction uses the control word c_0. It will interpret the expression 10 times, doing two comparisons
per logic scan (the Mode is 2). The comparisons will be f[10]


Use: 0.2789