Hide Transcript
View Transcript
It’s widely understood that computers –including
PLCs – do all the remarkable things they can do using only 1s and 0s. How exactly do they do
this? Well, that’s an ambitious question for a short video like this, but let’s look
at one aspect of that – data storage. If we could look at a physical representation of
data stored in a modern PLC, we’d see an expansive string or array of millions of 2-position (binary)
switches. A switch in the on position is generally represented as a 1, and in the off position a
0, and each of these switches we call a bit. So one bit can reflect or record a single
true / false condition. Something like an input signal being present or not.
To handle more sophisticated information, a computer needs to group bits into standardized
chunks or blocks. The most commonly known standard data chunk, the byte, contains 8 bits.
Back to our visualization of stored data, let’s think of these millions of bits divided
into bytes. The very first of these is, in programming fashion, referred to as
byte 0, followed by byte 1 and so on. This is a little simplified – the data
is more organized than this implies, but essentially this is how the CPU locates the
data it needs - by this numerical byte address. But once it finds the chunk of bits its
looking for, how does the CPU interpret them? This is where Data Types come in.
Each piece of data stored in the PLCs memory has a Data Type associated with it.
Let’s take a look at the elemental Data Types a PLC programmer will use in Do-More.
We mentioned the single bit, sometimes called a Boolean data type.
In Do-More, bytes are available as either signed or unsigned variables.
A chunk of 2 bytes – 16 bits – is known as a word. A word generally represents an
integer (whole number) value in a binary format, either signed or unsigned.
Comprising 32 bits, double words can be used to represent much larger numbers.
Real numbers likewise use 32 bits, but represent a fractional value in a decimal
format, or at least a close approximation thereof. With these data types, we can store and manipulate
all the information needed for any process a PLC could be tasked with. Let’s take a look at a
commonly used chunk of data like a date and time. The Year can be stored as an unsigned word, the
Month as an unsigned byte, and the Day as an unsigned byte, while the whole Date in numerical
format could be stored as a double word. Likewise, the time can be broken into elements that can
be stored in individual bytes or stored in a concatenated form as a double word. Data in
the PLCs memory is segmented with different data types assigned to specific allocated
blocks, so the elements of a time and date stamp could be scattered throughout the memory,
each with its own address. Certainly doable, but is there a more efficient way?
Enter data structures, commonly known as structs. A struct is essentially an amalgamation
of related data points that is stored and accessed as a single data type. As an example, lets take
a look at the counter struct built in to Do-More. To explore the memory configuration
in Do-More, drop down the PLC menu and select Memory Configuration. In the
window that opens, you’ll find three tabs. For now let’s skip to the third tab, Structs.
The default view is meant to display User Data Types. Unless you’re looking at a project in which
some of these have previously been implemented, you’ll see a blank table here. Select
Built-in Structs with the radio button here labeled Show. The table now populates
with all of Do-Mores built-in data structures. Double click the Counter struct to open its detail
window. You’ll see here all of the elements, or fields, that make up the structure.
The structure uses 2 double words as we can see here and comprises these 5 different
data fields. The first of these is called .Acc – it’s the accumulator that shows the
counter’s current count as a signed double word. The remaining fields are all bit elements
that indicate different statuses of the timer. In the Layout column we can see how these
different elements are arranged within the struct. .Acc is double word 1 whereas the bits are
all contained within double word 0, the lower word of the struct. The “Done” bit, for instance is
dw0:0, meaning that it is the rightmost or least significant bit of double word 0. For a visual
representation of the struct, View Memory Layout. While .Acc is read-write, the
status bits are read only. Display Format determines how the CPU will
by default represent the data contained in that field. To get a handle on this concept, let’s
open a Data window in Do-More Designer. For this, the programming environment must be connected to
either a live PLC or to the Do-More simulator. This is a good time to point out that we
are discussing a struct as a Data Type, or a definition of what a variable of this type will
contain – we aren’t looking at an actual variable. In the Data Window, or in ladder logic, there
is no way to access the Data Type – we can only look at an instance of a variable of
that type. Just for this example, we’ll look at a V variable – a single unsigned word.
Here we see the value in “Native” display format. In the case of an unsigned word, “Native” means
displayed as a numerical value, the way humans generally think of Numbers. This same information
can be displayed as a binary number, closer to the way computers handle things. Other format
options include hexadecimal… octal for old school programmers as well as more specialized forms like
timer values or IP addresses. Each ASCII character is stored as one byte, so a word encapsulates
2 characters – in this case, “hi.” Same data, same data type, but different ways to represent
it visually – for the benefit of us humans. While we’re at the data window, we’ll cover that
last column in the struct details window – the data view detail. Again, we’re going to
look at an instance of a variable of the Data Type we’re discussing, in this case the
Counter Struct. We’ll just pick counter CT0. In the data window or in a ladder logic
program, elements of the struct can be accessed individually, addressed like this: CT0.Acc,
for instance, or CT0.Done. In a Data window, you can also access the entire struct, with a
few choices of display styles. Notice that some fields show up in the long format but not the
short. This is what this last column refers to. Now we have all of our elemental data types and
we see the larger data types known as structs are essentially combinations of those basic types.
In the next video we’ll delve into the variables created with these data types and how they are
organized in the PLCs memory with Heap Items and Memory Blocks, along with the powerful
possibilities of User-Defined Data Types. Click here for that video
Click here for more Do-More videos Click here to subscribe to
Automation Direct’s You Tube channel