Learning Objectives

By the end of this lecture, you will be able to:

• Distinguish between signed and unsigned number representations

• Understand and apply 1’s complement and 2’s complement arithmetic

• Convert numbers to and from BCD (Binary Coded Decimal)

• Work with Gray code and understand its applications

• Encode and decode ASCII characters

• Choose appropriate binary representation for different applications

Why Different Binary Representations?

• Different applications need different representations

  • Arithmetic operations \(\to\) 2’s complement

  • Display systems \(\to\) BCD

  • Position sensing \(\to\) Gray code

  • Text processing \(\to\) ASCII

• Trade-offs to consider:

  • Storage efficiency vs. ease of conversion

  • Arithmetic simplicity vs. error reduction

  • Hardware complexity vs. software complexity

Unsigned Numbers

• Definition : Represent only non-negative integers (0, 1, 2, 3, ...)

• Range for n-bit : 0 to \((2^n - 1)\)

Example : \(1010_2 = 1×2^3 + 0×2^2 + 1×2^1 + 0×2^0 = 8 + 2 = 10_{10}\)

Signed Numbers: The Challenge

• Problem : How to represent negative numbers in binary?

• Solution approaches :

  1. Sign-Magnitude representation

  2. 1’s Complement

  3. 2’s Complement (Most widely used)

Key Consideration : We need to represent both positive and negative numbers using only 0s and 1s, while keeping arithmetic operations simple.

Sign-Magnitude Representation

• Method : Use leftmost bit as sign bit (0=positive, 1=negative)

• Range for n-bit : \(-(2^{n-1}-1)\) to \(+(2^{n-1}-1)\)

Problems : Two representations for zero, complex arithmetic

1’s Complement Representation

• Method : Invert all bits of positive number to get negative

• Range for n-bit : \(-(2^{n-1}-1)\) to \(+(2^{n-1}-1)\)

Example : Representing -5 in 4-bit 1’s complement

Issue : Still has two zeros (0000 and 1111)

2’s Complement Representation

• Method : 1’s complement + 1

• Range for n-bit : \(-2^{n-1}\) to \(+(2^{n-1}-1)\)

• Advantages : Single zero, simple arithmetic

Example : Representing -5 in 4-bit 2’s complement

Quick Method :

1. Start from right, copy bits until first 1 (inclusive)

2. Invert remaining bits

Example: \(0101 \rightarrow 1011\) (copy 01, invert 01 \(\to\) 10)

2’s Complement: Complete 4-bit Table

Note : Range is -8 to +7 (16 different values, one zero)

2’s Complement Arithmetic

Addition : Simply add binary numbers, ignore final carry

Example 1 : \(3 + 5 = 8\)

Example 2 : \(3 + (-5) = -2\)

Subtraction : Convert to addition: \(A - B = A + (-B)\)

Overflow in 2’s Complement

Overflow occurs when :

• Positive + Positive = Negative result

• Negative + Negative = Positive result

Example : \(7 + 2 = ?\) (in 4-bit)

Detection : Check if sign of result differs from expected

BCD (Binary Coded Decimal)

• Concept : Each decimal digit encoded separately in 4 bits

• Range per digit : 0000 (0) to 1001 (9)

• Unused codes : 1010, 1011, 1100, 1101, 1110, 1111

Example : \(59_{10} = 0101 \, 1001_{\text{BCD}}\)

BCD vs Pure Binary

Example : Representing 123

Comparison :

• BCD Advantages : Easy decimal conversion, used in displays

• BCD Disadvantages : 25% storage waste, complex arithmetic

Applications : Digital clocks, calculators, meters, displays

BCD Arithmetic Example

Addition : Add BCD digits, adjust if result > 9

Example : \(27 + 35\) in BCD

Correction needed : \(1100 > 1001\) , so add 6 (0110)

Gray Code Introduction

• Property : Adjacent numbers differ by exactly one bit

• Also known as : Reflected Binary Code, Unit Distance Code

• Key advantage : Minimizes errors during transitions

3-bit Gray Code Sequence :

Note: Each row differs from the next by only one bit!

Gray Code Construction

Method : Reflection technique

1. Start with 1-bit: 0, 1

2. For n+1 bits: Reflect n-bit sequence and prefix with 0 and 1

Example : Building 3-bit Gray code

Pattern :

• First half: prefix 0 to n-bit sequence

• Second half: prefix 1 to reversed n-bit sequence

Binary to Gray Code Conversion

Algorithm :

1. MSB of Gray = MSB of Binary

2. For other bits: \(G_i = B_{i+1} \oplus B_i\)

Example : Convert \(1011_2\) to Gray

Therefore: \(1011_2 = 1110_{\text{Gray}}\)

Gray to Binary Code Conversion

Algorithm :

1. MSB of Binary = MSB of Gray

2. For other bits: \(B_i = G_i \oplus B_{i+1}\)

Example : Convert \(1110_{\text{Gray}}\) to Binary

Therefore: \(1110_{\text{Gray}} = 1011_2\)

Gray Code Applications

• Rotary Encoders : Shaft position sensing

  • Prevents false readings during transitions

  • Critical in precision control systems

• A/D Converters : Reduces conversion errors

• Communication Systems : Error reduction in digital transmission

• Karnaugh Maps : Logic simplification (next lectures)

Why Gray Code for Encoders?

• Binary: 011 \(\to\) 100 (3 bits change simultaneously)

• Gray: 010 \(\to\) 110 (only 1 bit changes)

• Mechanical tolerances ensure only one sensor changes state

ASCII (American Standard Code for Information Interchange)

• Purpose : Standard for representing text characters

• Original : 7-bit code (128 characters, 0-127)

• Extended : 8-bit with parity or extended characters

• Characters include : Letters, digits, symbols, control characters

Character Categories :

• Control characters (0-31): Non-printable (CR, LF, TAB, etc.)

• Printable characters (32-126): Letters, digits, symbols

• DEL character (127): Delete

ASCII Table (Partial)

Key Patterns :

• Digits 0-9: ASCII 48-57 (add 48 to digit value)

• Upper case A-Z: ASCII 65-90

• Lower case a-z: ASCII 97-122 (upper case + 32)

ASCII Examples and Patterns

Example 1 : Encode "Hi!" in ASCII

Useful Patterns :

• Case conversion : Toggle bit 5

  • ’A’ (01000001) \(\leftrightarrow\) ’a’ (01100001)

• Digit to number : Subtract 48

  • ’7’ (55) - 48 = 7

• Alphabetical order : Preserved in ASCII values

Applications : Text files, keyboards, displays, communication protocols

When to Use Which Representation?

System Design Considerations :

• Storage requirements vs. processing speed

• Error tolerance vs. computational complexity

• Human interface requirements

Practice Problems

Problem 1 : Convert the following:

1. \(-13_{10}\) to 8-bit 2’s complement

2. \(247_{10}\) to BCD

3. \(1101_2\) to Gray code

4. "ACE" to ASCII (in hex)

Problem 2 : Identify the representation:

• A system needs to display decimal numbers on 7-segment displays

• A rotary encoder must track shaft position accurately

• A processor performs signed integer arithmetic

• A communication system transmits text messages

Summary

Key Takeaways :

• Signed Numbers : 2’s complement is most practical for arithmetic

• BCD : Trades storage efficiency for easy decimal interfacing

• Gray Code : Single-bit transitions prevent errors in analog systems

• ASCII : Universal standard for text representation

• Choice depends on : Application requirements, hardware constraints, error tolerance

Next Lecture : Boolean Algebra & Logic Simplification

• Fundamental theorems and postulates

• Karnaugh Maps (using Gray code!)

• Logic minimization techniques