Practical Examples of Binary Codes: BCD, Gray, and Excess-3 Exam Walkthrough

When you are debugging a digital encoder or designing a 7-segment display driver on a breadboard, you quickly realize that 'binary' is not just one format. Digital systems rely on specialized encoding schemes to handle decimal arithmetic, error prevention, and mechanical position tracking. For electronics students and hobbyists, mastering examples of binary codes is a rite of passage in digital logic exams and real-world circuit design.

This walkthrough dissects a classic multi-part digital logic exam problem. We will convert a single decimal number through four different coding schemes, showing every algebraic step, identifying the common traps, and verifying the results independently.

The Core Problem: Multi-Code Conversion Walkthrough

Step-by-Step Solution and Algebraic Logic

Let us break this down part by part, applying the correct theorem and method for each encoding scheme.

Part A: 8421 Binary-Coded Decimal (BCD)

Method: The 8421 BCD system does not convert the entire number into binary. Instead, it treats each decimal digit independently, replacing it with its 4-bit binary equivalent (weighted 8, 4, 2, 1). This is the standard used in Electronics Tutorials for driving decimal displays.

1. Isolate the digits: 5 and 8.
2. Convert 5: $4 + 1 = 0101_2$
3. Convert 8: $8 + 0 = 1000_2$
4. Concatenate: 0101 1000

Part B: Standard Pure Binary

Method: Successive division by 2, or summing powers of 2. We will use the sum of powers method for algebraic clarity.

1. Identify the largest power of 2 less than or equal to 58: $2^5 = 32$.
2. Subtract: $58 - 32 = 26$. (Bit 5 = 1)
3. Next power: $2^4 = 16$. Subtract: $26 - 16 = 10$. (Bit 4 = 1)
4. Next power: $2^3 = 8$. Subtract: $10 - 8 = 2$. (Bit 3 = 1)
5. Next power: $2^2 = 4$. 4 is greater than 2. (Bit 2 = 0)
6. Next power: $2^1 = 2$. Subtract: $2 - 2 = 0$. (Bit 1 = 1)
7. Next power: $2^0 = 1$. 1 is greater than 0. (Bit 0 = 0)
8. Assemble the bits ($B_5$ to $B_0$): 111010

Part C: Gray Code

Method: Gray code is a unit-distance code where only one bit changes between successive values. The theorem applied here is the Exclusive-OR (XOR) shift method. The formula is $G_n = B_n \oplus B_{n+1}$, where $B$ is standard binary and the MSB ($G_{n-1}$) is always copied directly from $B_{n-1}$.

1. Write standard binary with a leading zero for the XOR shift: $0111010$
2. $G_5 = B_5 = 1$
3. $G_4 = B_5 \oplus B_4 = 1 \oplus 1 = 0$
4. $G_3 = B_4 \oplus B_3 = 1 \oplus 1 = 0$
5. $G_2 = B_3 \oplus B_2 = 1 \oplus 0 = 1$
6. $G_1 = B_2 \oplus B_1 = 0 \oplus 1 = 1$
7. $G_0 = B_1 \oplus B_0 = 1 \oplus 0 = 1$
8. Assemble the Gray bits: 100111

Part D: Excess-3 Code

Method: Excess-3 is an unweighted, self-complementing code. The method requires adding 3 to each individual decimal digit, then converting those new sums into 4-bit standard binary.

1. Isolate digits: 5 and 8.
2. Add 3 to the first digit: $5 + 3 = 8$. Convert 8 to binary: $1000_2$.
3. Add 3 to the second digit: $8 + 3 = 11$. Convert 11 to binary: $1011_2$.
4. Concatenate: 1000 1011

The Trap, Verification, and Sanity Checks

The Trap in This Problem

The most frequent error students make is attempting to derive Gray code directly from BCD or by treating the decimal number as a base for the XOR shift. Gray code is strictly a positional binary reflection; it must be derived from pure binary. If you XOR the BCD nibbles (0101 and 1000) independently, you will generate a meaningless sequence that breaks the unit-distance property across the nibble boundary. Always convert to pure binary first.

How to Verify the Answer Independently

To verify the Gray code ($100111$) without relying on the original decimal number, perform the reverse Gray-to-Binary conversion using cascading XORs. The theorem is $B_n = G_n \oplus B_{n+1}$ (where $B_{n+1}$ is the previously calculated binary bit).

• $B_5 = G_5 = 1$
• $B_4 = G_4 \oplus B_5 = 0 \oplus 1 = 1$
• $B_3 = G_3 \oplus B_4 = 0 \oplus 1 = 1$
• $B_2 = G_2 \oplus B_3 = 1 \oplus 1 = 0$
• $B_1 = G_1 \oplus B_2 = 1 \oplus 0 = 1$
• $B_0 = G_0 \oplus B_1 = 1 \oplus 1 = 0$

The reconstructed binary is $111010$, which perfectly matches our Part B calculation. The logic holds.

Answer Sanity Check (Order of Magnitude and Units)

Before submitting an exam answer, check the bit lengths against the mathematical boundaries of the decimal input:

• Pure Binary & Gray Code: 58 falls between $32$ ($2^5$) and $63$ ($2^6 - 1$). Therefore, it requires exactly 6 bits. If your answer has 5 or 7 bits, you dropped a leading zero or miscalculated the MSB.
• BCD & Excess-3: These are digit-mapped codes. A 2-digit decimal number must map to exactly 2 nibbles, yielding 8 bits. If your Excess-3 result is 7 bits, you failed to pad the leading zero on the first nibble.

Frequently Asked Questions: Examples of Binary Codes

What are the most common examples of binary codes used in digital electronics?

Beyond the standard pure binary, the most common examples of binary codes include 8421 BCD (used in digital clocks and calculators for easy decimal translation), Gray Code (used in absolute rotary encoders to prevent mechanical reading errors), Excess-3 (historically used in early digital computers to simplify subtraction via 9s complement arithmetic), and ASCII/Extended ASCII (the foundational alphanumeric character encoding for microcontrollers and UART communication). For a deeper dive into character encodings, refer to the All About Circuits digital textbook.

Why is Gray code preferred over standard binary in rotary encoders?

Standard binary suffers from the 'multiple bit change' problem. For example, transitioning from 3 ($011$) to 4 ($100$) requires all three bits to flip simultaneously. In a physical optical or magnetic encoder, mechanical tolerances mean the sensors will never read the transition perfectly in sync, resulting in transient spurious values (like reading $111$ or $000$ for a fraction of a millisecond). Gray code is a 'unit-distance' code—only one bit changes between any two adjacent numbers. This guarantees that a sensor misalignment will only result in a reading of the exact previous or exact next position, completely eliminating catastrophic position glitches in motor control loops.

How do I handle the trap of converting fractional decimals to BCD?

Students often try to multiply the fractional part by powers of 2 when converting to BCD. This is incorrect. BCD strictly maps base-10 digits. To convert a fractional decimal like $0.47$ to BCD, you simply map the digits after the decimal point directly: 4 becomes $0100$, and 7 becomes $0111$. The BCD representation is $0.0100 0111$. Do not attempt base-2 fractional weighting (like $1/2, 1/4, 1/8$) when the target format is explicitly BCD.