Data Manipulation Instructions

Data Manipulation Concepts

So far in this book we’ve worked almost entirely with bits — single 1-or-0 values that represent contact states, coil states, sensor states, lamp states. Bit-level logic gets you a long way; you can build entire conveyor lines, batch fills, and start-stop circuits without ever moving anything bigger than a single bit.

But the moment you need to store a setpoint, read an analog sensor, look up a recipe, or do arithmetic, single bits are no longer enough. You need numbers — values like 120.5 °C, or recipe number 7, or oven setpoint 360 seconds. Numbers in a PLC live in data files, and the file type tells the PLC how to interpret the bits inside.

Data file types

Every modern PLC organises its memory into files, each holding values of one specific type:

The file letter (N, F, B, T, C, I, O) tells the PLC how to interpret the bits. Mixing them up is a common beginner error: try to MOV from F8:0 (float) into N7:0 (integer) and you’ll truncate the decimal portion silently. Try to MOV from N7:0 into F8:0 and the integer becomes a float — usually fine, but you should know it’s happening.

Once you have data in the right file, you have to do something with it. The two basic actions are moving data (copy a value from A to B) and comparing data (test whether one value is equal to / greater than / less than another). The next two sections cover each in turn.

Data Transfer (MOV) Operations

Data transfer instructions copy a value from a source register to a destination register. The source isn’t changed; only the destination receives the new value. Four instructions cover almost every transfer need:

MOV — single-word move

The workhorse. Copies one value from source to destination on each scan that the rung is true.

MOV source: N7:5 destination: N7:20

That rung copies whatever’s in N7:5 into N7:20 every scan the rung is true. If you want to do the move only once (when a button is pressed, for example), put a one-shot in the rung — otherwise the destination is overwritten every scan.

MVM — masked move

Copies selected bits from source to destination, leaving the other bits in the destination unchanged. The “mask” is a 16-bit pattern: where the mask is 1, the bit is copied; where the mask is 0, the destination bit is preserved.

MVM source: N7:5 mask: 0000 0000 1111 0000 dest: N7:20

That rung copies bits 4–7 from N7:5 into bits 4–7 of N7:20. Bits 0–3 and 8–15 of N7:20 are untouched. Useful when several different program sections each “own” different bits of a shared status word.

COP — file copy

Copies an array of words — N elements in a row. Useful for loading a recipe (10 parameters at once) or transferring a logged set of samples.

COP source: #N7:50 destination: #N7:100 length: 10

That rung copies N7:50–N7:59 into N7:100–N7:109. The # prefix tells the PLC “this is the start of an array, not a single word”.

FLL — file fill

Writes the same value into every word of an array. Useful for clearing a buffer or initialising an array of setpoints.

FLL source: 0 destination: #N7:100 length: 10

That rung writes 0 into N7:100–N7:109 — the same as 10 consecutive MOVs of zero, but in one instruction.

Data Compare Instructions

Comparators are input-style instructions. They sit on the left side of a rung where you’d normally put XIC contacts. Their output is true (passing power) when the comparison they describe is true; false otherwise. The rung’s coil fires according to that result.

Seven comparators handle every numeric test you’ll need:

The LIM instruction is special

LIM tests three values at once: a low limit, the test value, and a high limit. Its output is true when the test value is between the two limits. This is enormously more compact than wiring two separate comparators (LEQ + GEQ) in series — one LIM, three sources, done.

An interesting quirk: if the engineer programs Low > High (e.g., Low = 50, High = 10), LIM treats it as an inverted test — true when the test value is OUTSIDE the [10, 50] range. This is occasionally useful but is a frequent source of confusion, so most engineers stick to writing Low < High and using NEQ-style logic when they want “outside window”.

Comparators with floats

Floating-point equality is tricky. A value computed as 0.1 + 0.2 doesn’t exactly equal 0.3 due to IEEE-754 rounding. Avoid EQU on floats; use a LIM with a small tolerance band instead. For example: “level is at setpoint” → LIM source A: SP−0.5 test: PV source B: SP+0.5.

Data Manipulation Programs — Recipes, Lookup Tables, and File Operations

Once you have the basic move and compare instructions in your toolkit, the patterns they enable are some of the most powerful in PLC programming. Three patterns cover the majority of real-world data-manipulation work.

Recipe selection

A machine that runs multiple products needs different setpoints for each one — different cook times, different temperatures, different mix ratios. Hard-coding 25 separate cases is unmaintainable. Better: store each product’s parameters as a contiguous block in memory (a “recipe”) and use COP to load the chosen recipe into the running tags.

The structure looks like this:

• Recipe storage: N7:50–N7:59 = recipe 1, N7:60–N7:69 = recipe 2, etc.
• Active recipe (running): N7:100–N7:109 — the parameters the program currently uses.
• Selection: an EQU comparator on the operator’s selection number triggers a COP that copies the right recipe into the active block.

Adding a new recipe is now just adding 10 more words of data — no code changes. We’ll build this out in Worked Example 1.

Lookup tables

Some calculations are easier as a table than as math. The classic case is non-linear sensor calibration: a thermocouple’s reading-vs-temperature curve isn’t a straight line, but a 50-point table with linear interpolation between points captures the curve perfectly. The PLC indexes into the table using the raw reading and reads out the calibrated temperature. The MOV-with-indexed-address pattern (e.g. MOV N7:[N7:0] N7:50) makes this one rung.

File arithmetic and statistics

For batch operations across an entire array — “compute the average of these 100 samples”, “find the maximum”, “sort this list” — the FAL (File Arithmetic Logic), AVE, STD, and SRT instructions exist. They operate on whole arrays the way MOV operates on single words. We won’t dive deep into FAL in this chapter; the key idea is to recognise that any operation you can do on a single value, you can do on a whole array with one rung if your platform supports it.

Numerical Data I/O Interfaces

Numbers don’t only live inside the PLC — they have to get in and out. Operators set values on physical interfaces; displays show values to the team on the floor. Most modern installations use HMIs and touch-screens, but two older but still-common interfaces are worth understanding: BCD thumbwheel switches (input) and BCD 7-segment displays (output).

BCD encoding — what it is

BCD stands for Binary Coded Decimal. Each decimal digit (0–9) is encoded as 4 bits — the binary representation of that digit. So the number “37” in BCD takes 8 bits: 0011 for the 3, then 0111 for the 7. The number “1024” in BCD takes 16 bits: 0001 0000 0010 0100.

BCD is wasteful compared to plain binary (you can’t use the patterns 1010–1111 in any digit position), but it has one huge practical advantage: each decimal digit lives in its own 4-bit nibble. That means a 4-digit BCD thumbwheel switch wires directly to the PLC: 4 wires per digit, 16 wires total, each thumbwheel switch turning gives you a clean 4-bit binary representation of that digit.

FRD and TOD instructions

BCD numbers in the PLC’s memory aren’t directly usable by math instructions — math expects plain binary integers. So the PLC has two conversion instructions:

• FRD — From BCD — Converts a BCD-encoded number (read from a thumbwheel input word) into a plain binary integer. The result is stored in an N7 file ready for use in math, comparisons, and recipe lookups.
• TOD — To BCD — Converts a plain binary integer back into BCD encoding ready to drive a 7-segment display module.

Where this still matters

Most new builds use HMI screens for everything, so BCD interfaces are less common than they once were. But:

• Legacy machinery in service for 20+ years often still has thumbwheel switches and 7-segment indicators, and you’ll need to read and write them.
• Simple panel-mount interfaces for setpoints (a single thumbwheel for “batch count target”) are still widely used because they are mechanically rugged and require no software on the operator side.
• Some safety-rated interfaces still mandate physical switches over touch-screens — and those switches typically come back into the PLC as BCD.

Introduction to Closed-Loop Control

Until now, our PLC programs have been mostly discrete: a switch turns on, a motor runs; a sensor blocks, a counter increments. The PLC observes inputs and decides outputs. There’s no continuous measurement of how well the machine is performing the task.

Now imagine controlling the temperature of a chemical reactor. You can turn the heater on or off — but if you simply leave it on, the reactor overheats. If you turn it off and on by a temperature limit switch, the temperature swings up and down dramatically. To hold the temperature steady at exactly 75 °C, you need closed-loop control: continuously measure the temperature, compare it to the desired setpoint, and adjust the heater output proportionally.

Open-loop vs closed-loop

The distinction is clear once you see it:

• Open-loop control: the controller commands the actuator and hopes for the best. There’s no feedback measurement of whether the goal was achieved. Example: a timed bake — turn on the oven for 30 minutes regardless of actual oven temperature.
• Closed-loop control: the controller measures the result, computes the error, and adjusts the actuator continuously to drive the error toward zero. Example: a thermostatically controlled oven — measure temperature, compare to setpoint, modulate heater power based on the difference.

Components of a feedback loop

• Setpoint (SP) — the desired value, set by the operator. “I want the temperature to be 75 °C.”
• Process variable (PV) — the actual measured value, read from a sensor. “The temperature right now is 71.4 °C.”
• Error (E) — the difference: E = SP − PV. “Error is +3.6 °C; we’re below setpoint.”
• Control variable (CV) — what the controller commands the actuator to do. “Open the heater valve to 60 %.”
• Process — the physical thing being controlled (the reactor, the tank, the temperature, the flow rate).

The simplest controller — proportional only

A proportional (P) controller sets the actuator output proportional to the error: bigger error, bigger correction. The math is one line:

CV = K_p × (SP − PV)

K_p is the proportional gain, a number you tune. Larger gains make the controller respond faster but risk oscillation; smaller gains are stable but slow. A pure P-controller will leave a small steady-state offset (a non-zero error at equilibrium), which is why most real systems add an integral (I) term to drive that offset to zero, plus a derivative (D) term to anticipate rate of change. The combination is the famous PID controller.

Modern PLCs include a dedicated PID instruction that wraps all three terms, gain scheduling, output limiting, anti-windup protection, and tuning interfaces in one block. We’ll use the PID instruction in detail in later chapters; for this chapter we’ll build a P-only controller by hand using SUB and MUL — both to demystify what the PID block is doing under the hood and to give you a tool you can use today on simple loops.