Introduction

Excess-3 (XS-3) code is a non-weighted BCD code in which each decimal digit is coded as the 4-bit binary of (digit + 3). It was used in early computers and calculators because it makes decimal arithmetic easier.

Excess-3 table

Codes 0000, 0001, 0010, 1101, 1110, 1111 are invalid (unused).

How to convert

Add 3 to each decimal digit separately, then write each result in 4-bit binary.

Example 1: $(39)_{10}$

• 3 + 3 = 6 → 0110
• 9 + 3 = 12 → 1100
• $(39)_{10} = (0110\ 1100)_{XS-3}$

Example 2: $(258)_{10}$

• 2 → 0101, 5 → 1000, 8 → 1011
• $(258)_{10} = (0101\ 1000\ 1011)_{XS-3}$

Properties

1. Unweighted code: bit positions have no fixed weights.
2. Self-complementing: the 9's complement of a digit is obtained by simply inverting all bits. For example, 4 = 0111; inverting gives 1000 = 5 in XS-3, and $9 - 4 = 5$. This made subtraction simple in old machines.
3. No all-zero code: every valid code has at least one 1, which helps detect a dead line.
4. Easy addition: when two XS-3 digits are added, a carry occurs exactly when the decimal sum exceeds 9. Correction: if there is a carry, add 0011 to the digit; if no carry, subtract 0011.

Addition example: $4 + 5$

• $0111 + 1000 = 1111$, no carry
• subtract 0011: $1111 - 0011 = 1100$ = 9 in XS-3

Excess-3 is therefore a convenient BCD code for decimal arithmetic, though it needs more bits than pure binary.

A digital signal has only a finite set of discrete levels (usually 0 and 1), while an analog signal varies continuously. Digital signals have these advantages:

1. Noise immunity: small noise does not change a 0 into a 1, so the signal is received correctly. Analog signals are corrupted by every bit of noise.
2. Regeneration: a digital signal can be fully restored by repeaters, so noise does not accumulate over long distances.
3. Easy storage: data can be stored in memory, discs and flash without loss of quality, and copied any number of times exactly.
4. Easy processing: digital data can be processed by computers and microprocessors using software.
5. Error detection and correction: parity bits and codes (Hamming, CRC) can find and fix errors.
6. Encryption and compression are easy to apply.
7. Accuracy and precision are set by the number of bits, and do not drift with temperature or ageing.
8. Design and integration: digital circuits are easy to design and fit in ICs with millions of gates, giving low cost and small size.
9. Multiplexing: many digital signals (voice, video, data) share one channel easily (TDM).

Example: a song copied many times on an audio cassette (analog) becomes noisy, but an MP3 file copied many times stays exactly the same.

Gray code is an unweighted binary code in which two successive numbers differ in only one bit. It is also called the reflected binary code or a unit-distance code.

4-bit Gray code table

Binary to Gray

MSB stays the same; each next Gray bit = XOR of the current and previous binary bits: $G_i = B_{i+1} \oplus B_i$.

Example: $(1011)_2$ → G = 1, 1⊕0 = 1, 0⊕1 = 1, 1⊕1 = 0 → $(1110)_{Gray}$.

Gray to binary

MSB stays the same; each next binary bit = previous binary bit XOR current Gray bit: $B_i = B_{i+1} \oplus G_i$.

Example: $(1110)_{Gray}$ → B = 1, 1⊕1 = 0, 0⊕1 = 1, 1⊕0 = 1 → $(1011)_2$.

Uses

• Shaft position (rotary) encoders: only one bit changes per step, so no false reading at transitions.
• K-map labelling (00, 01, 11, 10).
• Reducing switching errors in counters and ADCs.

BCD (Binary Coded Decimal) is a code in which each decimal digit (0–9) is represented separately by its 4-bit binary equivalent. It is also called the 8421 code, since the four bits have weights 8, 4, 2 and 1.

BCD table

The six combinations 1010 to 1111 are invalid in BCD.

Examples

• $(259)_{10}$ = 0010 0101 1001 (BCD)
• $(47)_{10}$ = 0100 0111 (BCD), whereas in pure binary $47 = 101111_2$.
• BCD 1001 0011 = $(93)_{10}$.

BCD addition

Add the digits in binary. If the 4-bit sum is greater than 1001 (9) or a carry is produced, add 0110 (6) to correct it.

Example: $7 + 5$

    0111      (7)
  + 0101      (5)
  ------
    1100      invalid (>9)
  + 0110      add 6
  ------
  1 0010   -> 0001 0010 = 12

Advantages

• Easy conversion between decimal and BCD; ideal for displays (7-segment), calculators, digital clocks and meters.
• Decimal fractions such as 0.1 are exact.

Disadvantages

• Needs more bits than pure binary (e.g. 99 needs 8 bits in BCD, 7 in binary), so storage is wasted.
• Arithmetic is more complex because of correction steps.
• Six of the 16 combinations are unused.

ASCII (American Standard Code for Information Interchange) is a 7-bit alphanumeric code that represents $2^7 = 128$ characters: letters, digits, punctuation and control codes. It is the standard code for text in computers and for data exchange between devices.

Groups of characters

• 0–31 and 127: control characters (e.g. LF = 10, CR = 13, ESC = 27, DEL = 127).
• 32: space; 33–47 etc.: punctuation and symbols.
• 48–57: digits '0'–'9' (011 0000 to 011 1001).
• 65–90: capital letters 'A'–'Z'; 97–122: small letters 'a'–'z'.

Examples

So "CAT" is stored as 43H 41H 54H. Lower-case letters are 32 (bit 5) higher than capitals. An 8th bit is often added as a parity bit or for the extended ASCII set (256 characters).

BCD code

BCD (Binary Coded Decimal) represents each decimal digit separately by its 4-bit binary value (8421 weights). Only 0000–1001 are valid; 1010–1111 are invalid. Example: $(93)_{10}$ = 1001 0011 (BCD), while in binary $93 = 1011101_2$. BCD is used in calculators, clocks and 7-segment displays.

3-bit binary to Gray code converter

Inputs: binary $B_2B_1B_0$ ($B_2$ = MSB). Outputs: Gray $G_2G_1G_0$. In Gray code, successive values differ in only one bit.

Truth table (3-bit binary to Gray)

Simplification (K-maps)

• $G_2 = \sum m(4,5,6,7) = B_2$
• $G_1 = \sum m(2,3,4,5) = \bar B_2 B_1 + B_2\bar B_1 = B_2 \oplus B_1$
• $G_0 = \sum m(1,2,5,6) = \bar B_1 B_0 + B_1\bar B_0 = B_1 \oplus B_0$

K-map for $G_1$ (rows $B_2$, columns $B_1B_0$):

        B1B0
 B2    00  01  11  10
  0  |  0 | 0 | 1 | 1 |
  1  |  1 | 1 | 0 | 0 |

Logic circuit

 B2 ---+------------------------ G2
       |    +-------+
       +--->|       |
            |  XOR  |----------- G1
 B1 ---+--->|       |
       |    +-------+
       |    +-------+
       +--->|       |
            |  XOR  |----------- G0
 B0 ------->|       |
            +-------+

The converter needs only two XOR gates: the MSB passes straight through and each other Gray bit is the XOR of two neighbouring binary bits.

Decimal 39 to Gray code

First convert to binary by repeated division by 2:

Reading upwards: $(39)_{10} = (100111)_2$.

Binary to Gray (keep MSB, then XOR adjacent bits):

 Binary : 1   0   0   1   1   1
          |  / \ / \ / \ / \ /
 Gray   : 1   1   0   1   0   0

$G = 1,\ 1\oplus0=1,\ 0\oplus0=0,\ 0\oplus1=1,\ 1\oplus1=0,\ 1\oplus1=0$

Answer: $(39)_{10} = (110100)_{Gray}$

Decimal 39 to Excess-3

Add 3 to each digit: 3 + 3 = 6 → 0110; 9 + 3 = 12 → 1100.

Answer: $(39)_{10} = (0110\ 1100)_{XS-3}$

(−28) + (17) using 2's complement (8-bit)

• $+28 = 0001\ 1100$
• 1's complement: $1110\ 0011$; add 1 → $-28 = 1110\ 0100$
• $+17 = 0001\ 0001$

    1110 0100   (-28)
  + 0001 0001   (+17)
  -----------
    1111 0101   no end carry

No end carry, so the result is negative and in 2's complement form. Take the 2's complement to find its magnitude: $0000\ 1010 + 1 = 0000\ 1011 = 11$.

Answer: $(-28) + 17 = 1111\ 0101_2 = (-11)_{10}$

Gray code

Gray code is an unweighted, reflected binary code in which successive numbers differ in only one bit position. Examples: 0 = 000, 1 = 001, 2 = 011, 3 = 010. It is used in shaft encoders and K-maps because only one bit changes at each step, avoiding false intermediate values.

3-bit binary to Gray code converter

Inputs: $B_2B_1B_0$ (binary, $B_2$ = MSB). Outputs: $G_2G_1G_0$.

Truth table (3-bit binary to Gray)

Simplification (K-maps)

• $G_2 = \sum m(4,5,6,7) = B_2$
• $G_1 = \sum m(2,3,4,5) = \bar B_2 B_1 + B_2\bar B_1 = B_2 \oplus B_1$
• $G_0 = \sum m(1,2,5,6) = \bar B_1 B_0 + B_1\bar B_0 = B_1 \oplus B_0$

K-map for $G_1$ (rows $B_2$, columns $B_1B_0$):

        B1B0
 B2    00  01  11  10
  0  |  0 | 0 | 1 | 1 |
  1  |  1 | 1 | 0 | 0 |

Logic circuit

 B2 ---+------------------------ G2
       |    +-------+
       +--->|       |
            |  XOR  |----------- G1
 B1 ---+--->|       |
       |    +-------+
       |    +-------+
       +--->|       |
            |  XOR  |----------- G0
 B0 ------->|       |
            +-------+

The converter needs only two XOR gates: the MSB passes straight through and each other Gray bit is the XOR of two neighbouring binary bits.

(i) $(1110)_{Gray}$ to BCD

Gray to binary: MSB is copied; each next binary bit = previous binary bit XOR current Gray bit.

$(1110)_{Gray} = (1011)_2 = (11)_{10}$. Each decimal digit in BCD: 1 → 0001, 1 → 0001.

Answer: $(1110)_{Gray} = (0001\ 0001)_{BCD}$

(ii) $(1430)_{10}$ to Excess-3

Add 3 to each digit and write in 4 bits:

Answer: $(1430)_{10} = (0100\ 0111\ 0110\ 0011)_{XS-3}$

(iii) (−28) + 17 using 2's complement (8 bits)

• $+28 = 0001\ 1100$
• 1's complement $= 1110\ 0011$; add 1: $-28 = 1110\ 0100$
• $+17 = 0001\ 0001$

    1110 0100   (-28)
  + 0001 0001   (+17)
  -----------
    1111 0101   (no end carry)

The MSB is 1 and there is no end carry, so the result is negative in 2's complement form. Magnitude: 2's complement of $1111\ 0101$ = $0000\ 1010 + 1 = 0000\ 1011 = 11$.

Check: $-28 + 17 = -11$.

Answer: $1111\ 0101_2 = (-11)_{10}$

Analog signal

An analog signal is a continuous signal that can take any value within a range at every instant of time, e.g. a sine wave, voice from a microphone, or temperature from a thermocouple.

Digital signal

A digital signal takes only a finite number of discrete values (usually two: 0 and 1) and changes only at discrete instants, e.g. the clock or data in a computer.

 Analog :   /\    /\        Digital:  _   __    _
           /  \  /  \                | | |  |  | |
          /    \/    \             __| |_|  |__| |__

Gray code

Gray code is an unweighted, reflected binary code in which consecutive numbers differ in only one bit.

Binary to Gray: keep MSB, then $G_i = B_{i+1} \oplus B_i$. Example: $(1011)_2$ → 1, 1⊕0 = 1, 0⊕1 = 1, 1⊕1 = 0 → $(1110)_{Gray}$. Used in shaft encoders and K-maps.

Excess-3 code

Excess-3 is an unweighted BCD code where each decimal digit is coded as the binary of digit + 3.

Example: $(27)_{10}$ → 2+3 = 5 → 0101, 7+3 = 10 → 1010 → $(0101\ 1010)_{XS-3}$. It is self-complementing: inverting the bits gives the 9's complement (e.g. 2 = 0101 → 1010 = 7 = 9 − 2).

Gray code

Gray code is an unweighted binary code in which two successive values differ in only one bit. It is also called the reflected binary code. Example sequence: 000, 001, 011, 010, 110, 111, 101, 100.

Difference from binary code

Convert $(10110)_2$ to Gray

Keep the MSB; each following Gray bit is the XOR of two adjacent binary bits.

 Binary: 1   0   1   1   0
         | \ | \ | \ | \ |
 Gray  : 1   1   1   0   1

• $G_4 = B_4 = 1$
• $G_3 = 1 \oplus 0 = 1$
• $G_2 = 0 \oplus 1 = 1$
• $G_1 = 1 \oplus 1 = 0$
• $G_0 = 1 \oplus 0 = 1$

Answer: $(10110)_2 = (11101)_{Gray}$

(i) $(41.8125)_{10}$ to binary

Integer part (repeated division by 2):

Reading upwards: $41 = 101001$.

Fraction part (repeated multiplication by 2):

Reading downwards: $0.8125 = .1101$.

Answer: $(41.8125)_{10} = (101001.1101)_2$

(ii) $(1000)_2$ to BCD

$(1000)_2 = 8$, and the digit 8 in BCD is 1000.

Answer: $(1000)_2 = (1000)_{BCD}$ (for a two-digit view, 0000 1000)

(iii) $(19)_{10}$ to Excess-3

Add 3 to each digit: 1 + 3 = 4 → 0100; 9 + 3 = 12 → 1100.

Answer: $(19)_{10} = (0100\ 1100)_{XS-3}$

BCD (Binary Coded Decimal) is a code in which each decimal digit 0–9 is represented by its own 4-bit binary value with weights 8-4-2-1. Codes 1010–1111 are invalid. Example: $(57)_{10}$ = 0101 0111 (BCD).

Advantages

1. Very easy conversion between decimal and BCD, as each digit is coded separately.
2. Suitable for decimal displays (7-segment), calculators, digital clocks and meters, where numbers are shown to people.
3. Decimal fractions such as 0.1 are represented exactly, so it is used in financial calculations.
4. Easy to scale by powers of 10 (shift by one digit).

Disadvantages

1. Needs more bits than pure binary: $(99)_{10}$ needs 8 bits in BCD but only 7 in binary; storage is wasted.
2. Six of the 16 4-bit combinations are unused.
3. Arithmetic is more complex: after binary addition a correction (add 0110) is needed when a digit exceeds 9.
4. Circuits for BCD arithmetic are slower and more complex than binary circuits.

Gray code is an unweighted, reflected binary code in which successive numbers differ in only one bit position. It is used in shaft position encoders, K-maps and ADCs to avoid errors during transitions.

Comparison with binary numbers

Example: $(0111)_2$ → Gray $(0100)$.

Characteristics of analog and digital signals

Convert $(A2.64)_{16}$ to octal

Write each hex digit in 4 bits:

$A = 1010,\ 2 = 0010,\ 6 = 0110,\ 4 = 0100$

$(A2.64)_{16} = (1010\ 0010\ .\ 0110\ 0100)_2$

Regroup into 3-bit groups from the binary point (left for integer, right for fraction), padding with zeros:

 Integer : 010 100 010   ->  2 4 2
 Fraction: 011 001 000   ->  3 1 0

Answer: $(A2.64)_{16} = (242.31)_8$

Convert $(A2.64)_{16}$ to decimal

$$\begin{aligned} (A2.64)_{16} &= 10\times16^1 + 2\times16^0 + 6\times16^{-1} + 4\times16^{-2} \\ &= 160 + 2 + 0.375 + 0.015625 \\ &= 162.390625 \end{aligned}$$

Check from octal: $2\times64 + 4\times8 + 2 + 3/8 + 1/64 = 162.390625$.

Answer: $(A2.64)_{16} = (162.390625)_{10}$

Convert the integer and fraction parts separately.

Integer part: 37

Reading upwards: $37 = 100101$.

Fraction part: 0.432

The fraction does not terminate, so we stop after 10 bits. Reading downwards: $0.432 \approx .0110111010$.

Answer: $(37.432)_{10} \approx (100101.0110111010)_2$

Check: $100101.0110111010_2 = 37 + 442/1024 = 37.4316$, very close to 37.432.

Decimal 39 to binary

Answer: $(39)_{10} = (100111)_2$

Decimal 39 to hexadecimal

39 ÷ 16 = 2 remainder 7, and 2 ÷ 16 = 0 remainder 2. (Check: group binary 0010 0111 → 2 7.)

Answer: $(39)_{10} = (27)_{16}$

(−28) + 17 using 2's complement (8 bits)

• $+28 = 0001\ 1100$
• 1's complement: $1110\ 0011$; add 1 → $-28 = 1110\ 0100$
• $+17 = 0001\ 0001$

    1110 0100   (-28)
  + 0001 0001   (+17)
  -----------
    1111 0101   no end carry

No end carry and MSB = 1, so the answer is negative in 2's complement form. Its magnitude is the 2's complement: $0000\ 1010 + 1 = 0000\ 1011 = 11$.

Answer: $1111\ 0101_2 = (-11)_{10}$

(i) $(1110)_{Gray}$ to BCD

Step 1: Gray to binary. Copy the MSB; each next binary bit = previous binary bit ⊕ current Gray bit.

$(1110)_{Gray} = (1011)_2 = 8 + 2 + 1 = (11)_{10}$

Step 2: decimal to BCD. Code each digit: 1 → 0001, 1 → 0001.

Answer: $(1110)_{Gray} = (0001\ 0001)_{BCD}$

(ii) $(1430)_{10}$ to Excess-3

Add 3 to each digit and write it in 4 bits:

Answer: $(1430)_{10} = (0100\ 0111\ 0110\ 0011)_{XS-3}$

Group the bits in fours starting from the binary point: to the left for the integer part and to the right for the fraction, padding with zeros.

 Integer : 10      -> 0010 -> 2
 Fraction: .0101   -> 0101 -> 5

Check in decimal: $(10.0101)_2 = 2 + 0.25 + 0.0625 = 2.3125$, and $(2.5)_{16} = 2 + 5/16 = 2.3125$.

Answer: $(10.0101)_2 = (2.5)_{16}$

Rule: the MSB of the Gray code equals the MSB of binary; every other Gray bit is the XOR of the corresponding binary bit and the bit to its left: $G_i = B_{i+1} \oplus B_i$.

Answer: $(101001001)_2 = (111101101)_{Gray}$

In Excess-3 code each decimal digit is coded separately as the 4-bit binary of (digit + 3).

Answer: $(93)_{10} = (1100\ 0110)_{XS-3}$

Digital signal

A digital signal is a signal that has only a finite number of discrete values (usually two levels, 0 and 1) and changes at discrete instants of time. Example: clock pulses and data in a computer.

Gray code

Gray code is an unweighted binary code in which two consecutive numbers differ in only one bit. It is also called the reflected binary code, because the code for $n$ bits is built by writing the $(n-1)$-bit code, reflecting it like a mirror, and prefixing 0 to the top half and 1 to the bottom half.

 1-bit   2-bit    3-bit
  0       00       000
  1       01       001
 ---      11       011
 mirror   10       010
         ----      110
         mirror    111
                   101
                   100

Binary to Gray: keep the MSB; $G_i = B_{i+1} \oplus B_i$. Example: $(1101)_2$ → 1, 1⊕1 = 0, 1⊕0 = 1, 0⊕1 = 1 → $(1011)_{Gray}$.

Gray to binary: keep the MSB; $B_i = B_{i+1} \oplus G_i$. Example: $(1011)_{Gray}$ → 1, 1⊕0 = 1, 1⊕1 = 0, 0⊕1 = 1 → $(1101)_2$.

Features and uses

• Unweighted, so not used for arithmetic.
• Only one bit changes per step, so it avoids false readings in rotary shaft encoders.
• Used to label K-map rows and columns (00, 01, 11, 10).
• Used in ADCs and low-power counters.

Digital IC signal levels

Digital IC signal levels are the voltage ranges that an IC family accepts or produces as logic 0 (LOW) and logic 1 (HIGH). Any voltage in the forbidden band between them is not a valid logic level. For standard TTL (5 V supply):

 5.0 V +--------------+
       |  logic 1     |  input HIGH: 2.0 to 5 V
 2.0 V +--------------+
       |  forbidden   |
 0.8 V +--------------+
       |  logic 0     |  input LOW: 0 to 0.8 V
 0   V +--------------+

Noise margin = $V_{OH(min)} - V_{IH(min)} = 2.4 - 2.0 = 0.4$ V (same for LOW: $0.8 - 0.4 = 0.4$ V). For 5 V CMOS, typical levels are $V_{IL} = 1.5$ V and $V_{IH} = 3.5$ V.

Gray code

Gray code is an unweighted, reflected binary code in which successive numbers differ in only one bit.

Binary to Gray: keep MSB, then $G_i = B_{i+1} \oplus B_i$. Example: $(1001)_2$ → 1, 1⊕0 = 1, 0⊕0 = 0, 0⊕1 = 1 → $(1101)_{Gray}$. It is used in shaft encoders and K-maps because only one bit changes per step.

Convert hex to binary (4 bits per digit), then regroup in 3 bits from the point.

$(41A.2D)_{16} = 0100\ 0001\ 1010\ .\ 0010\ 1101$

 Integer : 010 000 011 010  -> 2 0 3 2
 Fraction: 001 011 010      -> 1 3 2

Answer: $(41A.2D)_{16} = (2032.132)_8$

Integer part: 37 ÷ 8 = 4 r 5; 4 ÷ 8 = 0 r 4 → $(45)_8$.

Fraction part (multiply by 8):

The digits then repeat (6, 3, 1, 4, …).

Answer: $(37.85)_{10} \approx (45.66314)_8$

First $(19)_{10} = (10011)_2$ (16 + 2 + 1). Then keep the MSB and XOR adjacent bits:

$G = 1,\ 1\oplus0 = 1,\ 0\oplus0 = 0,\ 0\oplus1 = 1,\ 1\oplus1 = 0$

Answer: $(19)_{10} = (11010)_{Gray}$

Subtract 3 (0011) from each 4-bit group to get the decimal digit, then write it in BCD.

Answer: $(1100\ 0011)_{XS-3} = (90)_{10} = (1001\ 0000)_{BCD}$

ASCII code

ASCII (American Standard Code for Information Interchange) is a 7-bit alphanumeric code that represents 128 characters: letters, digits, symbols and control characters. Example: 'A' = 65 = 100 0001, 'a' = 97 = 110 0001, '0' = 48 = 011 0000.

Binary (BCD) to Excess-3 code converter

Inputs: 4-bit binary/BCD digit $ABCD$ ($A$ = MSB), valid 0–9. Outputs: Excess-3 code $WXYZ$ = input + 3. Inputs 10–15 never occur, so they are don't cares (X).

K-map simplification

Minterms (don't cares $d = 10$–$15$):

• $W = \sum m(5,6,7,8,9) + d$
• $X = \sum m(1,2,3,4,9) + d$
• $Y = \sum m(0,3,4,7,8) + d$
• $Z = \sum m(0,2,4,6,8) + d$

K-map for $W$ (rows $AB$, columns $CD$):

          CD
 AB     00  01  11  10
 00   |  0 | 0 | 0 | 0 |
 01   |  0 | 1 | 1 | 1 |
 11   |  X | X | X | X |
 10   |  1 | 1 | X | X |

Groups: $A$ (rows 11 and 10), $BD$, $BC$.

Simplified expressions:

$$\begin{aligned} W &= A + BC + BD \\ X &= \bar B C + \bar B D + B\bar C\bar D \\ Y &= CD + \bar C\bar D \\ Z &= \bar D \end{aligned}$$

(All ten rows of the table were checked against these equations.)

Logic circuit (basic gates)

 A ----------------------------+
 B --+--[AND]-- BC ------------+--[OR]--- W
 C --+                         |
 B --+--[AND]-- BD ------------+
 D --+

 B'--+--[AND]-- B'C -----------+
 C --+                         |
 B'--+--[AND]-- B'D -----------+--[OR]--- X
 D --+                         |
 B --+                         |
 C'--+--[AND]-- BC'D' ---------+
 D'--+

 C --+--[AND]-- CD ------------+--[OR]--- Y
 D --+                         |
 C'--+--[AND]-- C'D' ----------+
 D'--+

 D ----[NOT]---------------------------- Z

NOT gates generate $\bar B$, $\bar C$, $\bar D$. The circuit uses 7 AND gates, 3 OR gates and 4 NOT gates (three for the complements, one for Z).

Digital system

A digital system is a system that processes information in discrete form, usually as binary signals 0 and 1, e.g. a computer, calculator or digital watch.

Logic level

A logic level is one of the discrete voltage states used to represent a binary value: HIGH (logic 1) and LOW (logic 0). For TTL, an input of 2.0–5 V is HIGH and 0–0.8 V is LOW.

BCD vs binary code

To decimal

$$\begin{aligned} (623.77)_8 &= 6\times8^2 + 2\times8 + 3 + 7\times8^{-1} + 7\times8^{-2} \\ &= 384 + 16 + 3 + 0.875 + 0.109375 \\ &= 403.984375 \end{aligned}$$

Decimal: $(403.984375)_{10}$

To binary

Replace each octal digit by 3 bits: 6 = 110, 2 = 010, 3 = 011, 7 = 111, 7 = 111.

Binary: $(110010011.111111)_2$

To hexadecimal

Regroup the binary into 4 bits from the point:

 Integer : 0001 1001 0011  -> 1 9 3
 Fraction: 1111 1100       -> F C

Hexadecimal: $(193.FC)_{16}$ (check: $403 + 252/256 = 403.984375$)

(i) $(21)_8$ to binary

Write each octal digit in 3 bits: 2 = 010, 1 = 001.

$(21)_8 = (010\ 001)_2$ = $(10001)_2$ (check: $2\times8 + 1 = 17 = 16 + 1$).

(ii) $(671)_{10}$ to BCD

Code each decimal digit in 4 bits:

Answer: $(671)_{10} = (0110\ 0111\ 0001)_{BCD}$

(iii) $(110101.011)_2$ to decimal

$$\begin{aligned} &= 1\cdot2^5 + 1\cdot2^4 + 0\cdot2^3 + 1\cdot2^2 + 0\cdot2^1 + 1\cdot2^0 + 0\cdot2^{-1} + 1\cdot2^{-2} + 1\cdot2^{-3} \\ &= 32 + 16 + 4 + 1 + 0.25 + 0.125 \\ &= 53.375 \end{aligned}$$

Answer: $(110101.011)_2 = (53.375)_{10}$

Discrete vs continuous signal

A continuous (analog) signal is defined at every instant of time and can take any value in a range. A discrete-time signal is defined only at specific (sampled) instants; if its values are also limited to fixed levels, it is a digital signal.

 Continuous x(t)          Discrete x[n]
    __                       |  |
   /  \      /             | |  | |
  /    \    /              | |  | |  |
 /      \__/            ---+-+--+-+--+--- n
---------------- t         0 1  2 3  4

Convert $(25.25)_{10}$ to binary

Integer: 25 → 25/2 = 12 r1, 12/2 = 6 r0, 6/2 = 3 r0, 3/2 = 1 r1, 1/2 = 0 r1 → $11001$. Fraction: 0.25 × 2 = 0.5 → 0; 0.5 × 2 = 1.0 → 1 → $.01$.

Answer: $(25.25)_{10} = (11001.01)_2$

Convert $(25.25)_{10}$ to octal

Integer: 25 ÷ 8 = 3 r 1; 3 ÷ 8 = 0 r 3 → $31$. Fraction: 0.25 × 8 = 2.0 → 2. (Check by grouping binary: 011 001 . 010 → 3 1 . 2.)

Answer: $(25.25)_{10} = (31.2)_8$

Integer: 26 ÷ 2 = 13 r0, 13 ÷ 2 = 6 r1, 6 ÷ 2 = 3 r0, 3 ÷ 2 = 1 r1, 1 ÷ 2 = 0 r1 → read upwards: $11010$.

Fraction: 0.75 × 2 = 1.5 → 1; 0.5 × 2 = 1.0 → 1 → $.11$.

Answer: $(26.75)_{10} = (11010.11)_2$

$$\begin{aligned} (36.735)_8 &= 3\times8^1 + 6\times8^0 + 7\times8^{-1} + 3\times8^{-2} + 5\times8^{-3} \\ &= 24 + 6 + 0.875 + 0.046875 + 0.009765625 \\ &= 30.931640625 \end{aligned}$$

Answer: $(36.735)_8 = (30.931640625)_{10}$

Gray to binary: copy the MSB; each next binary bit = previous binary bit ⊕ current Gray bit.

$B = 1,\ 1\oplus0 = 1,\ 1\oplus1 = 0,\ 0\oplus0 = 0,\ 0\oplus1 = 1$ → $(11001)_2$

$(11001)_2 = 16 + 8 + 1 = 25$

Answer: $(10101)_{Gray} = (25)_{10}$

Subtract 3 (0011) from each group to get the decimal digit, then write it in BCD.

Answer: $(1001\ 1010)_{XS-3} = (67)_{10} = (0110\ 0111)_{BCD}$

Importance of coding

Digital systems understand only 0s and 1s, so numbers, letters and symbols must be coded into binary patterns. Coding allows data to be stored, processed and exchanged in a standard way, makes displays easy (BCD), reduces errors (Gray code, parity, Hamming code) and allows secure or compressed transmission.

ASCII code

ASCII (American Standard Code for Information Interchange) is a 7-bit alphanumeric code representing $2^7 = 128$ characters:

• 0–31 and 127: control characters (e.g. CR = 13, LF = 10).
• 48–57: digits '0'–'9'; 65–90: 'A'–'Z'; 97–122: 'a'–'z'.

Examples: 'A' = 65 = 100 0001 (41H); 'a' = 97 = 110 0001 (61H); '5' = 53 = 011 0101. An 8th bit is often used for parity or extended ASCII.

$$\begin{aligned} (101101.011)_2 &= 2^5 + 2^3 + 2^2 + 2^0 + 2^{-2} + 2^{-3} \\ &= 32 + 8 + 4 + 1 + 0.25 + 0.125 \\ &= 45.375 \end{aligned}$$

Answer: $(101101.011)_2 = (45.375)_{10}$

Copy the MSB; each next binary bit = previous binary bit ⊕ current Gray bit.

Answer: $(110111)_{Gray} = (100101)_2$ (= 37 in decimal)

Convert octal to binary (3 bits per digit), then regroup in 4 bits from the right.

5 = 101, 2 = 010, 4 = 100 → $(101\ 010\ 100)_2$

Regroup: $0001\ 0101\ 0100$ → 1 5 4

Check: $(524)_8 = 5\times64 + 2\times8 + 4 = 340$, and $(154)_{16} = 256 + 80 + 4 = 340$.

Answer: $(524)_8 = (154)_{16}$

Integer: 125 → 62 r1, 31 r0, 15 r1, 7 r1, 3 r1, 1 r1, 0 r1 → read upwards: $1111101$.

Fraction: 0.25 × 2 = 0.5 → 0; 0.5 × 2 = 1.0 → 1 → $.01$.

Check: $64 + 32 + 16 + 8 + 4 + 1 + 0.25 = 125.25$.

Answer: $(125.25)_{10} = (1111101.01)_2$

Advantages of digital systems

1. Noise immunity: small noise does not change 0 into 1, so results are reliable.
2. Easy storage: data is stored in memories without loss and copied exactly.
3. Accuracy and precision depend only on the number of bits, not on component drift.
4. Programmability: operation can be changed by software.
5. Error detection and correction using parity and codes.
6. Easy design and high integration: millions of gates on one IC give low cost, small size and low power.
7. Regeneration: signals can be restored by repeaters during transmission.

BCD code

BCD (8421) code represents each decimal digit 0–9 separately by its 4-bit binary value. Codes 1010–1111 are invalid. Example: $(59)_{10}$ = 0101 1001 (BCD).

Excess-3 code

Excess-3 (XS-3) is an unweighted BCD code in which each decimal digit is coded as the binary of (digit + 3). It is self-complementing: inverting the bits gives the 9's complement. Example: $(59)_{10}$: 5 + 3 = 8 → 1000, 9 + 3 = 12 → 1100 → $(1000\ 1100)_{XS-3}$.

Integer part: 329 ÷ 16 = 20 r 9; 20 ÷ 16 = 1 r 4; 1 ÷ 16 = 0 r 1 → $(149)_{16}$.

Fraction part (multiply by 16):

The fraction does not terminate, so we stop at 5 digits.

Answer: $(329.54)_{10} \approx (149.8A3D7)_{16}$

$$\begin{aligned} (BD.1A)_{16} &= 11\times16 + 13\times1 + 1\times16^{-1} + 10\times16^{-2} \\ &= 176 + 13 + 0.0625 + 0.0390625 \\ &= 189.1015625 \end{aligned}$$

Answer: $(BD.1A)_{16} = (189.1015625)_{10}$

Rule (Gray to binary): the MSB of binary equals the MSB of Gray. Each next binary bit = previous binary bit XOR current Gray bit, $B_i = B_{i+1} \oplus G_i$.

Check: converting 01100101 back to Gray ($G_i = B_{i+1} \oplus B_i$) gives 01010111 again.

Answer: $(01010111)_{gray} = (01100101)_2$ (= $101_{10}$).

Rule: an excess-3 (XS-3) code word is the BCD code of each decimal digit plus 3 (0011). So subtract 0011 from each 4-bit group to get the BCD digit.

So the decimal number is 74.

Answer: $(1010\ 0111)_{XS\text{-}3} = (0111\ 0100)_{BCD}$ (= $74_{10}$).

Analog and digital signal

• Analog signal: a signal that varies continuously with time and can take any value within a range. Example: the voltage from a microphone, output of a thermocouple, a sine wave $v = V_m \sin \omega t$.
• Digital signal: a signal that takes only a finite number of discrete values, usually two levels (HIGH = 1, LOW = 0), and changes in steps. Example: the clock pulse in a computer, the output of a TTL gate (0 V / +5 V).

 Analog                 Digital
   .-.     .-.           __    __    __
  /   \   /   \         |  |  |  |  |  |
 /     \ /     \     ___|  |__|  |__|  |__
        '              t ->

Advantages of digital systems over analog systems

1. Noise immunity: only two levels need to be told apart, so small noise does not change the information.
2. Accuracy and precision: accuracy can be increased simply by using more bits; analog accuracy is limited by component tolerance.
3. Easy storage: digital data can be stored for a long time in memories (RAM, ROM, flash, disks) without degradation.
4. Programmability: the operation of a digital system can be changed by software (e.g. microprocessors).
5. Easy design: design uses switching (Boolean) algebra; exact voltage values are not important.
6. Integration: many gates can be placed on one IC chip, so systems are small, cheap and reliable.
7. Easy processing and transmission: data can be encrypted, compressed, error-checked and copied without loss.
8. Less effect of temperature and ageing on circuit behaviour.