Data Inside PLC
Think of PLC memory as
a cabinet with drawers called Registers. Data is held in these
Registers.These Registers come in different sizes, and hold different kinds of
data.
Bits:Can have values 1 or 0. 1 typically
represents On while 0 represents Off. Bits are the building block for all
other types of data.
Integers:Whole numbers (no decimal points).
Called: Characters (char), Integers (int), long Integers (long int) or
Words. Look for the bit size and whether they are signed or unsigned.
Unsigned are positive numbers, while signed are positive or negative.
Floating point numbers: Numbers with decimal points, and can be
positive or negative. They are called floating point numbers (Float), with
their larger variety called double floats.
Type

# bits

Signed/Unsigned

Min Value

Max Value

Bit

1

0

1


Int

8

Signed

128

127

Unsigned

0

255


16

Signed

32,768

32,767


Unsigned

0

65,535


32

Signed

2,147,483,648

2,147,483,647


Unsigned

0

4,294,967,295


Floating Point

32

1.175 E–38

3.403 E+38


64

2.225 E–308

1.798 E+308

Addresses/Tags: The Registers are all stacked side by
side in the PLC’s memory. Each location has an Address that lets the PLC
know what data you’re talking about. Older PLC software requires the user
to refer to data by this Address (example “x1023” could mean the 1023’d
register). Some newer software makes the Addresses transparent. The user
gives a piece of data a name (example “Oven2Temperature”), and the PLC keeps
track of where the register is located. If the software uses Addresses to refer
to data it’s called “Address Based”, if it uses named data it’s called “Tag
Based”. Some programming packages are Address Based, but allow Addresses
to have “Nicknames” or something similar. Their benefits over standard Address
Based systems tend to be limited. Advantages to Tag based systems become
evident as programs grow, and remembering what’s stored in x1023 becomes
difficult. If your program is going to have any complexity at all using
a Tag Based System simplifies the design.
Diving Deeper
Inside the Data Types: As stated earlier, all Data Types are made
of Bits (1′s and 0′s). An 8 bit number is written like bbbbbbbb (where “b” can
represent a 0 or 1), so you may have 00000000, 11111111 or 01011110…. any
combo will do. What these Bits mean is determined by the Data Type.
Unsigned Integers: The least valuable bit is the rightmost bit
and double in value each position you move left. The rightmost bit
is 1 it’s worth 1 next bit to the left 2 4 8 16 32
64 128 256 …… (this goes on for as many bits as the Data Type calls
for). Here’s what its looks like for an Unsigned 8bit Integer:
If all 8 bits are 0
(00000000) then we get 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 = 0
If all 8 bits are 1
(11111111) then we get 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255
So the range of an 8
bit unsigned Integer is 0 – 255
An example of something in between
(00110101) 0 + 0 + 32 + 16 + 0 + 4
+ 0 + 1 = 53
Signed Integers: They’re a tad more complicated check
out wikipedia’s
article on 2’s compliment for a good understanding.
Hexadecimal Format (Hex): Instead of writing every bit out, it
is common to group sets of 4 bits together. Each group can have a value of 0 –
15, which causes a problem since our number system goes from 0 – 9, so we also
use A, B, C, D, E and F to get a total of 16 values. (0, 1, 2, 3, 4, 5, 6, 7,
8, 9 , A, B, C, D, E, F)
Example 1001 0011 1111 0010 in Hex would be
93F2
To be clear that we’re using Hex format we
tack on a ‘0x’ the the start of the number so our last example would be written
0x93F2
Characters: (typically 8 bit unsigned integers) are
often used to represent letter or symbols. Example: you may use them to
display text on an operator panel. Use an ASCII table to see how values are
mapped to symbols.
What about the bits in Floating Point numbers,
how do they break out? It is somewhat complicated, I don’t really want to get
into that in this Post. It is unlikely as a PLC user that you will ever
need to know how their bits translate to values, so don’t worry about it.
The Basics  Maths
Addition, Subtraction, Multiplication and Division are
what you’d expect. If you haven’t done math in a programming language before,
there are a couple of things you should be aware of.
·
Overflow: Integers and Floating Point Numbers
have size limits. When you go beyond their size you’ll cause
yourself problems.
Example: 8 bit Unsigned Int with value 255 in bits looks like 11111111.
If we add 1 to it we get 100000000. There isn’t storage for a 9′th bit, so
we’re left with 00000000 or 0. So in this case 255 + 1 = 0
Another Example: 8 bit Unsigned Int with value 0 in bits looks like
00000000. If we subtract 1 to it we get 11111111. So, we can get the opposite
problem 0 – 1 = 255
·
Rounding: Floating Point numbers aren’t perfect.
For this reason, you shouldn’t check to see if Floating point numbers are
equal to a value, you should check to see if it’s within a range of
numbers.
Example: 2 * 3 performed with Floating Point numbers may not result in
exactly 6.
It could be 5.9999999999998 or something similar. So instead of asking is
Example = 6, ask is Example greater than 5.9 and less than 6.1. Don’t worry
about how to ask these questions, we’ll talk about that later in the tutorial
Boolean Math
Some programming
packages allow bit manipulation by using Boolean Math. The
main operations are:
OR (symbol ‘’ ): A = B  C. If
either B is 1 or C is 1, then A is 1. If both B and C are 0, then A is 0.
AND (symbol ‘&’): A = B & C. If both
B and C are 1, then A is 1. If either B of C are 0, then A is 0.
Exclusive OR (symbol ‘⊕’): A = B ⊕ C. If either B is 1 or C is 1, but not
both, then A is 1. If both B and C are 1, or both B and C are 0 then A is
0.
Example: 8 bit Unsigned Int with value 255 in bits looks like 11111111. If we add 1 to it we get 100000000. There isn’t storage for a 9′th bit, so we’re left with 00000000 or 0. So in this case 255 + 1 = 0
Another Example: 8 bit Unsigned Int with value 0 in bits looks like 00000000. If we subtract 1 to it we get 11111111. So, we can get the opposite problem 0 – 1 = 255
Example: 2 * 3 performed with Floating Point numbers may not result in exactly 6.
It could be 5.9999999999998 or something similar. So instead of asking is Example = 6, ask is Example greater than 5.9 and less than 6.1. Don’t worry about how to ask these questions, we’ll talk about that later in the tutorial
No comments:
Post a Comment