Related Concepts: 2.01 BCD & Weighted Digital Codes | 2.02 Excess-3 Code & Self-Complementing Logic | 2.04 Error Control, Parity Generators & Checkers

2.03 Gray Code & Code Conversions

What is Gray Code?

Gray Code (also called Reflected Binary Code) is an $N$-bit non-weighted binary coding system. Its defining property is that only one bit changes state (from 0 to 1 or 1 to 0) between any two consecutive values.

---

1. Physical Significance: Why Use Gray Code?

Standard binary numbers are ideal for math, but they cause severe glitches when interfacing with the physical world due to simultaneous multi-bit transitions:

A. Rotary Shaft Encoders (Position Sensing)

Optical sensors read angular position from coded disks:

• The Binary Problem: Transitioning from decimal 3 (011) to 4 (100) requires three bits to flip at once. Due to microscopic mechanical misalignments, the sensors will not trigger at the exact same instant. For a fraction of a millisecond, the processor might read an erroneous state like 111 (decimal 7) or 010 (decimal 2), leading to positioning errors.
• The Gray Code Solution: Transitioning from 3 (010 in Gray) to 4 (110 in Gray) flips only the MSB. The sensor is physically guaranteed to read either 3 or 4, with no intermediate erroneous states.

B. Low-Power VLSI Design

In high-speed integrated circuits, flipping bus lines charges/discharges parasitic capacitances, consuming dynamic power. By using Gray code, the average number of bit transitions (switching activity) is minimized, lowering power consumption.

---

2. 4-Bit Gray Code Lookup Table

Notice how the codes reflect. The second half is the mirror image of the first half (excluding the MSB).

Decimal Value	Standard Binary	Gray Code
0	0000	0000
1	0001	0001
2	0010	0011
3	0011	0010
4	0100	0110
5	0101	0111
6	0110	0101
7	0111	0100
8	1000	1100
9	1001	1101
10	1010	1111
11	1011	1110
12	1100	1010
13	1101	1011
14	1110	1001
15	1111	1000

---

3. Conversion Algorithms and Flows

Conversions between pure binary and Gray code are performed using the Exclusive-OR (XOR, $\oplus$) operator.

3.1 Binary-to-Gray Conversion

Binary-to-Gray Conversion Flow:
Binary:  B3 -------> B2 -------> B1 -------> B0
         |           |           |           |
         |           XOR         XOR         XOR
         v           v           v           v
Gray:    G3          G2          G1          G0

1. The MSB of the Gray code is identical to the MSB of the binary number: $G_{MSB}=B_{MSB}$
2. Each subsequent Gray bit is found by XORing the corresponding binary bit with the binary bit to its left: $G_i=B_i\oplus B_{i+1}(\text{for }i=N-2,\dots ,0)$

Binary-to-Gray Conversion: Convert Binary $1011$ to Gray

1. $G_3=B_3=1$
2. $G_2=B_3\oplus B_2=1\oplus 0=1$
3. $G_1=B_2\oplus B_1=0\oplus 1=1$
4. $G_0=B_1\oplus B_0=1\oplus 1=0$

Result: $1110_{\text{Gray}}$

---

3.2 Gray-to-Binary Conversion

Gray-to-Binary Conversion Flow:
Gray:    G3          G2          G1          G0
         |           ^           ^           ^
         |           |           |           |
         v           XOR         XOR         XOR
Binary:  B3 -------> B2 -------> B1 -------> B0

1. The MSB of the binary number is identical to the MSB of the Gray code: $B_{MSB}=G_{MSB}$
2. Each subsequent binary bit is found by XORing the previously calculated binary bit with the next Gray code bit: $B_i=B_{i+1}\oplus G_i(\text{for }i=N-2,\dots ,0)$

Gray-to-Binary Conversion: Convert Gray $1110$ to Binary

1. $B_3=G_3=1$
2. $B_2=B_3\oplus G_2=1\oplus 1=0$
3. $B_1=B_2\oplus G_1=0\oplus 1=1$
4. $B_0=B_1\oplus G_0=1\oplus 0=1$

Result: $1011_2$

---

4. Hardware Implementation

To design a combinational circuit that converts a 4-bit Gray code input ($G_3{G}_2{G}_1{G}_0$) to a 4-bit Binary output ($B_3{B}_2{B}_1{B}_0$), we map the Gray-to-Binary recurrence relations:

$B_3=G_3$ $B_2=G_3\oplus G_2$ $B_1=B_2\oplus G_1$ $B_0=B_1\oplus G_0$

This maps directly to a cascade of three XOR gates:

graph LR
    G3[Input G3] --> B3[Output B3]
    G3 --> XOR1[XOR Gate 1]
    G2[Input G2] --> XOR1
    XOR1 --> B2[Output B2]
    
    B2 --> XOR2[XOR Gate 2]
    G1[Input G1] --> XOR2
    XOR2 --> B1[Output B1]
    
    B1 --> XOR3[XOR Gate 3]
    G0[Input G0] --> XOR3
    XOR3 --> B0[Output B0]

---

The three traps in Gray code questions

1. Direction confusion. Binary→Gray XORs two input bits ($G_i=B_{i+1}\oplus B_i$). Gray→Binary XORs the previously computed output bit with the next input bit ($B_i=B_{i+1}\oplus G_i$). Getting these backwards produces a plausible-looking but wrong answer, and it is the single most common mistake here.
2. “Gray code number” means convert the whole value. If the question gives a decimal like $605$, go decimal → binary → Gray. Do not Gray-code each decimal digit separately — that is how BCD and 5211 work, not Gray. (See 2.01 BCD & Weighted Digital Codes §6 for the full 2018 question where both appear side by side.)
3. “Reflected code” is just Gray code. The 2017 and 2024 papers both use that name. If the term appears in a definitions question, say non-weighted code in which only one bit changes between consecutive values, and mention the shaft-encoder application for the extra mark.

---

Past Year Questions (PYQs)

Question (as asked)	Years	Marks	Solved in
Define reflected code (inside a multi-part definitions question)	2017	part of 10	§Abstract, §1
Convert $(605{)}_{10}$ into Gray code number (part iii of a 12-mark code-conversion question)	2018	part of 12	below, and 2.01 BCD & Weighted Digital Codes §6
Design a combinational circuit that converts a four-bit reflected code number to a four-bit binary number. Use XOR gates.	2024	10	§4

Worked solution — $(605{)}_{10}$ to Gray: convert to binary first, $605=1001011101_2$, then apply $G_{MSB}=B_{MSB}$ and $G_i=B_{i+1}\oplus B_i$:

	$B_9$	$B_8$	$B_7$	$B_6$	$B_5$	$B_4$	$B_3$	$B_2$	$B_1$	$B_0$
Binary	1	0	0	1	0	1	1	1	0	1
Gray	1	1	0	1	1	1	0	0	1	1

$(605{)}_{10}=(1101110011{)}_{\text{Gray}}$

Pattern to notice: Gray code is never a whole question on its own — it always arrives as one part of a larger code-conversion or converter-design question. The conversion itself is two lines of XOR, so the marks hinge on getting the direction right and on drawing a clean labelled XOR cascade for the hardware part.