Unit 1: Number Systems - Subjective Questions

Analog Systems:

• Deal with continuous signals that can take any value within a range.
• Signal varies smoothly over time.
• Susceptible to noise and signal degradation.
• Examples: Analog clock, mercury thermometer, audio amplifier.

Digital Systems:

• Deal with discrete signals having only finite values, typically two levels ( and ).
• Signal changes in steps.
• More noise-immune and easily reproducible.
• Examples: Digital computer, digital watch, calculators.

Key Differences:

Digital systems are preferred in modern electronics due to accuracy, ease of design, and reliability.

Positional Number System:

In a positional number system, the value of each digit depends on both the digit itself and its position within the number. Each position carries a weight that is a power of the base (radix) .

General Expression:

For a number in base with integer and fractional parts:

The decimal value is given by:

Expanded form:

Example:

• Here for decimal, for binary, for octal, for hexadecimal.
• The base determines the number of distinct digits used (0 to ).

Step 1: Convert to Binary (integer part)

Successive division by 2:

• r
• r
• r
• r
• r
• r
• r
• r

Reading upward:

Step 2: Convert to Binary (fractional part)

So

Binary Result:

Step 3: Octal (group in 3 bits from binary point)

Step 4: Hexadecimal (group in 4 bits)

Final Answers:

• Binary:
• Octal:
• Hexadecimal:

Signed Number Representations:

1's Complement: Obtained by inverting all bits of the positive number.

2's Complement: Obtained by adding to the 1's complement.

Representing in 8 bits:

Step 1:

Step 2 (1's Complement of ): Invert all bits:

Step 3 (2's Complement of ): Add 1 to 1's complement:

Summary:

• (1's complement)
• (2's complement)

Advantages of 2's Complement:

• Single representation for zero.
• Simplifies addition/subtraction (no end-around carry).
• Widely used in modern processors.

Given: , . We want .

Step 1: Find 2's complement of .

• 1's complement:
• Add 1:

Step 2: Add and 2's complement of :

1010

• 1001

  10011

Step 3: A carry () is generated out of the MSB. In 2's complement subtraction, this carry indicates a positive result and is discarded.

Result:

Verification: ✓

Note: If no carry were generated, the result would be negative and stored in 2's complement form.

Binary Coded Decimal (BCD):

In BCD, each decimal digit (–) is represented by its own 4-bit binary equivalent (also called 8421 code, based on the weights of positions).

Example: Represent in BCD:

Note: Only combinations to are valid. Codes to are invalid in BCD.

Advantages:

• Easy conversion between decimal and BCD.
• Useful in digital displays, calculators, and clocks.

Disadvantages:

• Less efficient — wastes 6 of 16 possible combinations.
• Arithmetic is more complex (requires correction factor of ).
• Requires more bits than pure binary for the same range.

Gray Code:

Gray code is a non-weighted, cyclic code in which two successive values differ in only one bit (unit distance code). It is used to minimize errors in electromechanical systems like shaft encoders.

Binary to Gray Conversion:

• The MSB of Gray = MSB of Binary.
• Each subsequent Gray bit = XOR of adjacent binary bits.

For :

Gray Code

Gray to Binary Conversion:

• The MSB of Binary = MSB of Gray.
• Each subsequent Binary bit = XOR of previous Binary bit and current Gray bit.

For Gray :

Binary

Parity Check Code:

A parity bit is an extra bit appended to a data word to make the total number of 1s either even (even parity) or odd (odd parity). It is a simple error-detection technique.

Even Parity: The parity bit is chosen so that the total number of 1s (including the parity bit) is even.

Odd Parity: The parity bit is chosen so that the total number of 1s is odd.

Example: Data = (four 1s)

• Even parity bit: (already even)
• Odd parity bit: (to make it odd)

Working:

• At the receiver, parity is rechecked. A mismatch indicates an error.

Limitations:

• Can detect only odd number of bit errors.
• Cannot detect an even number of bit errors.
• Cannot correct errors, only detect them.

Hamming Code:

Hamming code is an error-correcting code that can detect and correct single-bit errors. Parity bits are placed at positions that are powers of 2 ().

For 4 data bits, we need parity bits such that . Here , giving a 7-bit code.

Bit positions (1–7):

Data maps to .

Parity coverage (even parity):

• covers positions 1,3,5,7:
• covers positions 2,3,6,7:
• covers positions 4,5,6,7:

Arranging the code:

Hamming Code =

At the receiver, parity checks form a syndrome that gives the position of the erroneous bit, allowing correction.

Octal Addition:

Add column by column (base 8, carry when sum ):

• Units:
• Tens:
• Hundreds:

No carries needed:

Verification: ✓

Octal Subtraction:

Subtract column by column:

• Units:
• Tens:
• Hundreds:

Verification: ✓

Hexadecimal Addition:

• Units: write , carry
• Tens:

Verification: ✓

Hexadecimal Subtraction:

• Units: → borrow needed: , borrow
• Tens:

Verification: ✓

IEEE 754 Single Precision (32-bit) Format:

Value , where is the bias.

Representing :

Step 1: Sign bit (negative).

Step 2: Convert to binary:

• ,

Step 3: Normalize:

Step 4: Exponent

Step 5: Mantissa (fraction after the leading 1) padded to 23 bits:

Final Representation:

1 10000001 10110000000000000000000

• Sign:
• Exponent:
• Mantissa:

Weighted Codes:

• Each bit position is assigned a fixed weight.
• The value of a digit is obtained by summing the weights of positions with 1s.
• Examples: BCD (8421), 2421, 5211, 84-2-1.

Example: In 8421, .

Non-Weighted Codes:

• No specific weight is assigned to bit positions.
• Value cannot be computed by weighted sum.
• Examples: Gray code, Excess-3 code, ASCII.

Comparison Table:

Excess-3 is a special non-weighted, self-complementing code obtained by adding 3 to each BCD digit.

Base Conversion Methods:

1. Any Base to Decimal:

• Multiply each digit by its positional weight (power of base) and sum.

2. Decimal to Any Base:

• Integer part: Repeated division by the target base; remainders read bottom-to-top.
• Fractional part: Repeated multiplication by the target base; carries read top-to-bottom.

3. Binary ↔ Octal:

• Group binary digits in sets of 3 (from binary point).
• Each group = one octal digit (and vice versa).

4. Binary ↔ Hexadecimal:

• Group binary digits in sets of 4.
• Each group = one hex digit (and vice versa).

5. Octal ↔ Hexadecimal:

• Convert via binary as an intermediate step (octal → binary → hex).

Example: ; grouped as hex .

Fixed-Point Representation:

• The position of the binary/decimal point is fixed.
• Composed of an integer part and a fractional part of fixed length.
• Simple hardware, faster computation, but limited range.
• Example: In an 8-bit fixed-point with 4 integer and 4 fractional bits, .

Floating-Point Representation:

• The point can float; number is expressed as mantissa base.
• Provides a much larger dynamic range and handles very large/small numbers.
• Follows standards like IEEE 754.

Comparison:

Error Detection:

• The process of identifying whether errors have occurred during data transmission or storage.
• Does not fix the error, only flags it.
• Codes: Parity check, Checksum, Cyclic Redundancy Check (CRC).

Error Correction:

• The process of detecting and reconstructing the original error-free data.
• Requires additional redundant bits to locate and fix the error.
• Codes: Hamming code, Reed-Solomon code, BCH code.

Difference:

Key concept: The Hamming distance between valid codewords determines capability — a minimum distance can detect errors and correct errors.

Logic Circuits:

Logic circuits are electronic circuits that operate on binary inputs ( and ) to produce binary outputs based on Boolean logic. They form the building blocks of digital systems.

Classification:

1. Combinational Circuits:

• Output depends only on the present inputs.
• No memory element; no feedback.
• Examples: Adders, Subtractors, Multiplexers, Decoders, Encoders.

2. Sequential Circuits:

• Output depends on present inputs and past states (has memory).
• Uses feedback and storage elements.
• Examples: Flip-flops, Registers, Counters.

Basic Logic Gates:

• AND, OR, NOT (basic gates)
• NAND, NOR (universal gates)
• XOR, XNOR (used in arithmetic and parity)

These circuits are implemented using transistors and are combined to build complex digital systems like processors and memory.

Data Representation and Coding:

In digital systems, all types of data — numbers, characters, images, audio — must be represented using binary digits (bits). Coding is the process of assigning binary patterns to represent information.

Types of Data Representation:

• Numeric data: Binary, BCD, signed number formats, floating point.
• Character data: ASCII, EBCDIC, Unicode.
• Special codes: Gray code, Excess-3, parity codes.

Why Binary is Preferred:

• Two-state simplicity: Electronic devices easily represent two states (ON/OFF, HIGH/LOW).
• Reliability: Only two voltage levels needed → high noise immunity.
• Ease of implementation: Simple switching circuits (transistors) work naturally with two states.
• Boolean algebra: Well-suited to binary logic for design and analysis.
• Cost-effective and accurate compared to multi-level systems.

Thus binary forms the foundation of all digital computation and communication.

Complements:

Complements are used to simplify subtraction and logical operations in digital systems. For a base , two complements exist.

's Complement (Diminished Radix Complement):

• Obtained by subtracting each digit from .
• For binary (): the 1's complement (invert all bits).
• For decimal (): the 9's complement.

's Complement (Radix Complement):

• Obtained by adding to the 's complement.
• For binary: the 2's complement.
• For decimal: the 10's complement.

Examples:

• 9's complement of
• 10's complement of
• 1's complement of
• 2's complement of

Use: Subtraction becomes addition of and the 's complement of .

Implementation of Digital Systems:

A digital system is realized by combining logic gates and components to perform a desired function. Implementation can be done using SSI, MSI, LSI, VLSI components or programmable devices (PLDs, FPGAs, microcontrollers).

Design Steps:

1. Problem Specification: Clearly define the function, inputs, and outputs.
2. Truth Table Formation: List all input combinations and corresponding outputs.
3. Boolean Expression Derivation: Obtain logic equations (SOP/POS) from the truth table.
4. Simplification: Minimize the expression using Boolean algebra or K-maps to reduce gates.
5. Logic Diagram: Draw the circuit using logic gates.
6. Implementation: Realize using gates, ICs, or programmable hardware.
7. Testing and Verification: Simulate and test the circuit for correctness.

Implementation Approaches:

• Hardwired logic: Fixed function using discrete gates.
• Programmable logic: Flexible, reconfigurable (FPGA, PLA, PAL).
• Microprocessor/microcontroller-based: Software-driven implementation.

Good design aims for minimum cost, minimum gates, low power, and reliability.