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