Number Systems and Codes

The Decimal System — Where Everyone Starts

Let me start with something familiar. The decimal system is the one you’ve been using since you learned to count on your fingers. We call it “decimal” because it has ten symbols: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. The number of symbols always equals the base (also called radix) — and the largest symbol is one less than the base. Decimal’s base is 10, and the largest digit is 9.

Why bother going over decimal in a PLC chapter? Because decimal teaches us the rule that every number system follows: each digit’s value depends on its position. Each position carries a weight equal to the base raised to that position’s power, counting from 0 on the right. To find the value of the number, you multiply each digit by its weight and add it all up.

The little subscript ₁₀ after a number is just a label that says “this number is in base 10”. Without the subscript, 1010 could be decimal one thousand and ten, binary ten, octal eight-eighty-eight, or hex four-thousand-one-hundred-sixty-eight — all different! Whenever you write a number in a PLC context, always tell the reader the base.

The same rule — digit × weight, then add — works for every other number system. Only the base changes. Let’s see binary next.

The Binary System — How a PLC Actually Counts

The binary system has the smallest possible base — 2. It uses only two symbols: 0 and 1. That’s it. No 2, no 7, no 9. Just zero and one.

Each binary digit is called a bit (short for BInary digiT). Bits are packed into bigger groups:

• 1 byte = 8 bits (e.g. 11010110)
• 1 word = 16 bits (in older PLCs) or 32 bits (in modern ones)
• 1 double-word = 32 bits or 64 bits

The rightmost bit is the least-significant bit (LSB) — it has the smallest weight. The leftmost bit is the most-significant bit (MSB) — it has the largest weight. The position weights are powers of 2: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, ...

Binary to Decimal — The “Multiply and Add” Method

To convert a binary number to decimal, write down the position weights, multiply each bit by its weight, and add up the results. Same rule as decimal.

Notice we just skipped the bits that were 0 (they contribute nothing). Many engineers do this in their head with practice — just add up the weights of the positions where the bit is 1.

Decimal to Binary — The “Divide by 2” Method

Going the other way is a little less obvious but easy once you see the trick. Divide your decimal number by 2; the remainder (either 0 or 1) is the LSB. Divide the quotient by 2 again; the next remainder is the next bit. Keep going until the quotient hits zero, then read the remainders from bottom to top.

And there’s our cross-check: 10101101₂ = 173₁₀, exactly the number we converted in Example 2. Whenever you can, verify a conversion by going both directions — it catches arithmetic mistakes.

Negative Numbers — How a PLC Stores Minus Signs

So far we’ve only worked with positive numbers. But PLCs deal with negative values all the time — temperature deviations, motor reverse direction, errors that overshoot a setpoint. So how do you store a minus sign in binary, when binary only has 0s and 1s?

Three different schemes have been used over the decades. Modern PLCs use the third one (2’s complement) — but you should know all three because they show up in spec sheets.

1. Sign-Magnitude — The Obvious One

Reserve the leftmost bit (the MSB) as the sign bit. 0 = positive, 1 = negative. The remaining bits hold the magnitude. Easy to read but it has two representations of zero (+0 = 00000000 and −0 = 10000000) and the arithmetic is messy.

2. 1’s Complement — The Stepping Stone

To negate a number, just flip every bit (0 → 1, 1 → 0). It still has two zeros, and addition needs a special “end-around carry” step that’s awkward in hardware.

3. 2’s Complement — The Modern Standard

To negate a number: flip every bit, then add 1. That’s it. Just two steps. With this scheme there’s only one zero, and — here’s the magic — the same hardware adder handles both addition and subtraction. Every modern PLC, microprocessor, and computer uses 2’s complement.

The Octal System — Mostly Historical

The octal system has base 8 and uses the symbols 0 through 7. Position weights are powers of 8: 1, 8, 64, 512, ...

You’ll mostly meet octal in older PLC documentation. Why? Because three bits map cleanly to one octal digit (since 2³ = 8). On legacy controllers like the Allen-Bradley SLC 500, I/O terminal numbers are octal — which means terminal “10” on an octal-addressed module is actually the 9th terminal, not the 10th, because 10₈ = 8₁₀. (This trips up beginners every time.) Modern PLCs have largely abandoned octal in favour of decimal addressing or named tags.

Notice that 173₈ = 123₁₀, which is not the same as 173₁₀. Always read the subscript carefully — the same digits in different bases are completely different numbers.

The Hexadecimal System — Engineer’s Best Friend

The hexadecimal system (“hex” for short) has base 16. We have ten ordinary digits (0–9), but we need sixteen symbols. So hex borrows the letters A through F for the values 10 through 15:

Hex is the binary shorthand of choice in modern PLCs — and you’ll see why in a moment. Four bits map cleanly to one hex digit (since 2⁴ = 16). A 16-bit word becomes just four hex digits, much easier to read than sixteen 1s and 0s. PLC error codes, status registers, Modbus addresses, and memory addresses are nearly always shown in hex, often with a 0x or $ prefix to mark the base.

Going from hex to binary is just a lookup — no arithmetic. Just replace each hex digit with its 4-bit binary group. That’s why engineers love hex: it’s binary they can actually read out loud.

Side-by-Side Comparison Table

Memorise this table — at least the first few rows. It will save you time on every conversion you ever do:

Binary Coded Decimal (BCD) — Decimal Disguised as Binary

Sometimes industry needs to display decimal numbers directly — on a thumbwheel switch, on a seven-segment display, on a digital readout. Pure binary is awkward for this, because the binary representation of a decimal number has nothing to do with its decimal digit pattern.

The fix is Binary Coded Decimal (BCD): encode each decimal digit independently using its own 4-bit binary group. The 4-bit groups never go above 1001 (which is 9), so BCD wastes the codes 1010–1111 — they’re illegal in BCD.

BCD is wasteful but practical. Thumbwheel switches and seven-segment displays speak BCD natively, so a PLC reading a thumbwheel just reads each digit’s 4 bits and lights up the corresponding segments. Modern PLCs include dedicated BCD-input and BCD-output instructions to handle the conversion automatically.

Gray Code — Where Only One Bit Changes at a Time

The Gray code (named after Frank Gray, who patented it in 1953) is a non-weighted binary code with one defining property: adjacent values differ by exactly one bit. Going from 5 to 6 in pure binary changes two bits (0101 → 0110). In Gray code, going from 5 to 6 changes only one bit (0111 → 0101). That single property makes Gray code the standard for absolute shaft encoders — the sensors that report the angular position of a rotating shaft.

The 4-Bit Gray Code Sequence

Trace your finger down the Gray column: each row differs from the previous by exactly one bit. That’s the magic of the code.

ASCII Code — How PLCs Read Letters

ASCII (American Standard Code for Information Interchange) is the universal code that maps printable characters and control codes to 7-bit binary numbers (0–127). When a PLC talks to a barcode reader, a printer, a serial display, or any modern industrial network, the text data flows as ASCII.

Each ASCII character occupies one byte in memory. The eighth bit is unused, used as a parity bit (see next section), or used to extend the code to support international characters.

Common ASCII Characters

Parity Bit — Catching Single-Bit Errors

When binary data travels across a noisy channel — a long cable, a serial link, an industrial network — bits sometimes flip from 0 to 1 or vice versa due to electrical noise. The simplest way to detect such errors (note: detect, not correct) is the parity bit.

The idea is simple: append one extra bit to each data byte such that the total number of 1s in the augmented byte is either always even (even parity) or always odd (odd parity). The sender chooses the parity bit accordingly. The receiver counts the 1s and rejects any byte where the count doesn’t match.

Parity catches any odd number of bit errors (1, 3, 5, …) but misses any even number (2, 4, …). It also tells you a byte is wrong but cannot tell you which bit. For better protection, modern systems use checksums or CRCs (cyclic redundancy checks) — but parity is still common on serial links and inside RAM chips because it’s the simplest and fastest possible error check.

Binary Arithmetic — How the CPU Does Maths

Inside the PLC’s CPU, every calculation — every ADD, SUB, MUL, DIV instruction — happens in binary. Let’s see how the four basic operations work. The good news: they follow exactly the same long-form rules you learned for decimal in primary school. Only the digit set is smaller (just 0 and 1) and the carry happens earlier.

Binary Addition

Four single-bit rules cover everything:

• 0 + 0 = 0
• 0 + 1 = 1
• 1 + 0 = 1
• 1 + 1 = 10 (write 0, carry 1)

Just like decimal addition, you go right to left, propagating carries.

Binary Subtraction by 2’s Complement

Direct subtraction with borrows works, but it’s awkward for the CPU’s hardware. Instead, the processor adds the 2’s complement of the subtrahend. The same adder hardware then handles both addition and subtraction. Here’s the trick in action:

Binary Multiplication

Each bit of the multiplier produces either a copy of the multiplicand (if the bit is 1) or all zeros (if the bit is 0), shifted left by the bit’s position. Then add up the partial products.

Binary Division

Long division in binary works exactly like decimal long division, except every comparison is just “does the divisor fit?” — yes (write 1) or no (write 0). PLCs handle this automatically with a DIV instruction; you’ll rarely do it by hand.

Overflow — When the Result Doesn’t Fit

If the result of an addition or multiplication is too big to fit in the available number of bits, the operation produces an overflow. For an 8-bit signed register, 127 + 1 would yield 10000000 — which in 2’s complement is −128, not 128. The number wrapped around! PLCs raise an overflow status bit (often called S:0/0, S:OV, or similar) so your program can detect this and react. Always check overflow when working with counters, timers, and math instructions near their range limits.

Floating-Point Arithmetic — When Integers Aren’t Enough

Integer maths is fine for counting widgets and reading discrete sensors, but it can’t represent fractions like 3.14159 or very small/large numbers like 0.000001 or 1.23 × 10⁹. For those we need floating-point numbers.

Modern PLCs use the IEEE 754 single-precision standard — a 32-bit format with three fields:

This format gives roughly 7 decimal digits of precision and a range from about ±1.2 × 10⁻³⁸ to ±3.4 × 10³⁸. That’s more than enough for nearly any industrial calculation — PID setpoints, scaling, engineering-unit conversions, control loop maths. For tasks that need more precision, larger PLCs also support double-precision (64-bit) floats with about 15 decimal digits.