Related Concepts: 04 BCD and Weighted Digital Codes | 05 Excess-3 Code & Self-Complementing Logic | 09 XOR Gate Properties, Parity Generator & Error Checking

06 Gray Code & Code Conversions

What is Gray Code?

Gray Code (frequently termed Reflected Binary Code) is a 4-bit (or $N$-bit) non-weighted binary coding system.

According to the class notes, its defining fundamental property is: “A binary code system that changes ONLY ONE BIT at a time as it proceeds between any two consecutive code numbers.”

---

1. Why is it Called “Reflected” Code?

The code is named “reflected” because the sequence of code words for the second half of any $N$-bit Gray code sequence is the exact mirror image {reflection} of the first half, with the exception of the Most Significant Bit (MSB), which is inverted from 0 to 1.

2-Bit Gray Code Reflection Example:
Decimal 0:  0 0  ---| First half (MSB = 0)
Decimal 1:  0 1  ---|
-------------------- Reflection Axis
Decimal 2:  1 1  ---| Second half (MSB = 1, LSB reflected: 1 then 0)
Decimal 3:  1 0  ---|

---

2. Characteristics & Applications

Advantages (Merits)

• Eliminates Switching Errors & Spurious Transients: In standard binary counting, transitioning from $3_{10}$ (0111) to $4_{10}$ (1000) requires 4 bits to change state simultaneously. Due to unequal gate delays, temporary false intermediate output states {glitches} occur. In Gray code, only 1 bit flips (0010 $\to$ 0110), eliminating transient errors.
• Essential for Shaft Encoders & Position Sensors: Widely used in mechanical rotary encoders, optical position sensors, and analog-to-digital converters (ADCs) to prevent boundary positioning errors.
• Karnaugh Map (K-Map) Axis Indexing: Used for K-map row/column labels (00, 01, 11, 10) so adjacent cells differ by exactly 1 variable, satisfying adjacency laws.

Disadvantages (Demerits)

• Non-Weighted Code: Bit positions do not have fixed numerical weights.
• Unsuitable for Arithmetic: Direct addition, subtraction, or arithmetic manipulation is highly impractical without first converting to pure binary.

---

3. Conversion Algorithms & Formulas

Conversions between pure Binary and Gray code rely entirely on the Exclusive-OR (XOR, $\oplus$) operation.

graph TD
    subgraph Binary to Gray Algorithm
        B3[B3 MSB] --> G3[G3 = B3]
        B3 & B2[B2] -->|XOR| G2[G2 = B3 ⊕ B2]
        B2 & B1[B1] -->|XOR| G1[G1 = B2 ⊕ B1]
        B1 & B0[B0 LSB] -->|XOR| G0[G0 = B1 ⊕ B0]
    end

graph TD
    subgraph Gray to Binary Algorithm
        g3[G3 MSB] --> b3[B3 = G3]
        b3 & g2[G2] -->|XOR| b2[B2 = B3 ⊕ G2]
        b2 & g1[G1] -->|XOR| b1[B1 = B2 ⊕ G1]
        b1 & g0[G0 LSB] -->|XOR| b0[B0 = B1 ⊕ G0]
    end

A. Binary to Gray Code Conversion

Given an $N$-bit Binary number ($B_{N-1}\dots B_1{B}_0$), compute Gray bits ($G_{N-1}\dots G_1{G}_0$):

1. MSB Rule: The Most Significant Bit remains unchanged: $G_{N-1}=B_{N-1}$
2. Subsequent Bits Rule: XOR the current binary bit with the preceding binary bit: $G_i=B_{i+1}\oplus B_i\text{for }i=N-2,\dots ,0$

For a 4-bit number ($B_3{B}_2{B}_1{B}_0\to G_3{G}_2{G}_1{G}_0$): $G_3=B_3,G_2=B_3\oplus B_2,G_1=B_2\oplus B_1,G_0=B_1\oplus B_0$

---

B. Gray Code to Binary Conversion

Given an $N$-bit Gray code number ($G_{N-1}\dots G_1{G}_0$), compute Binary bits ($B_{N-1}\dots B_1{B}_0$):

1. MSB Rule: The Most Significant Bit remains unchanged: $B_{N-1}=G_{N-1}$
2. Subsequent Bits Rule: XOR the newly calculated binary bit with the next Gray bit: $B_i=B_{i+1}\oplus G_i\text{for }i=N-2,\dots ,0$

For a 4-bit number ($G_3{G}_2{G}_1{G}_0\to B_3{B}_2{B}_1{B}_0$): $B_3=G_3,B_2=B_3\oplus G_2,B_1=B_2\oplus G_1,B_0=B_1\oplus G_0$

---

4. Design: 4-Bit Reflected Code to Binary Converter Circuit

Major Exam Design Problem (2024 - 10 Marks)

Question: Design a combinational logic circuit that converts a 4-bit reflected code (Gray code) number to a 4-bit binary number using XOR gates.

Design Solution:

1. Inputs: 4-bit Reflected (Gray) Code ($G_3,G_2,G_1,G_0$).
2. Outputs: 4-bit Binary Code ($B_3,B_2,B_1,B_0$).
3. Boolean Equations: $B_3=G_3$ $B_2=G_3\oplus G_2$ $B_1=(G_3\oplus G_2)\oplus G_1=B_2\oplus G_1$ $B_0=((G_3\oplus G_2)\oplus G_1)\oplus G_0=B_1\oplus G_0$

Circuit Architecture:

The circuit is implemented using a cascading chain of three 2-input XOR gates:

• $G_3$ passes straight through to output $B_3$.
• $G_3$ and $G_2$ enter XOR Gate 1 $\to$ Output $B_2$.
• $B_2$ and $G_1$ enter XOR Gate 2 $\to$ Output $B_1$.
• $B_1$ and $G_0$ enter XOR Gate 3 $\to$ Output $B_0$.

---

Past Year Questions (PYQs)

1. Reflected Code Definition (2016 - 10 Marks Partial)

Question: Define Reflected code.

• Solution: Write: “A non-weighted binary code system in which adjacent code words differ by only one bit position, eliminating spurious switching errors during state transitions.”

2. Large Decimal to Gray Conversion (2018 - 12 Marks Partial)

Question: Convert the decimal number $(605{)}_{10}$ into a Gray code number.

Solution:

• Step 1: Convert $(605{)}_{10}$ to pure Binary: $605=512+64+16+8+4+1⟹(1001011101{)}_2$
• Step 2: Convert Binary $(1001011101{)}_2$ to Gray Code using XOR:
  • $B=1001011101$
  • $G=1101110011$
• Final Answer: $(1101110011{)}_{\text{Gray}}$.