Digital Systems Terms Booklet

This booklet is available as open material in the Digital Systems Final Test (Semester ‫ א‬, 5781).
The booklet does not cover all the material. Parts of it may be obvious, other parts may be helpful.

GRAY code – a type of cyclic code.

Translating (coding) an n-bit binary word X to Gray codeword Y

X (= xn-1 xn-2 … x2 x1 x0) ➔ Y (= yn-1 yn-2 … y2 y1 y0):

1) for k = n-1: yk = xk (Start on the left hand side, Most significant bit remains unchanged)

2) for k running from n-2 down to 0: yk = xk+1  xk

(XOR the current Binary digit with the previous Binary digit – to get the current Gray digit)

Translating (de-coding) a n-bit Gray codeword Y back to binary X

Y (= yn-1 yn-2 … y2 y1 y0) ➔ X (= xn-1 xn-2 … x2 x1 x0):

1) for k = n-1: yk = xk (Start on the left hand side, Most significant bit remains unchanged)

2) for k running from n-2 down to 0: xk = xk+1  yk

(XOR the current Gray digit with the previous Binary digit – to get the current Binary digit)

Error detection and correction formula:

m = 2c + d + 1
where: m - is the code distance
c – ("correct") – the number of errors that can be corrected
d – ("detect") – the number of additional errors that can be
detected; the total of errors that can be detected is c + d.
Hamming code – for a seven bit string
Info bits: M1 M2 M3 M4 Parity bits: P1 P2 P3
Transmitted String:
Bit number 1 2 3 4 5 6 7
Bit transmitted P1 P2 M1 P3 M2 M3 M4

P1 - is PARITY( P1,M1,M2,M4) P2 -is PARITY( P2,M1,M3,M4)

P3 - PARITY( P3,M2,M3,M4) (all even)

Received string:
Bit number 1 2 3 4 5 6 7
Bit recieved W1 W2 W3 W4 W5 W6 W7

A1=parity(W1,W3,W5,W7)
A2=parity(W2,W3,W6,W7)
A3=parity(W4,W5,W6,W7)
Error position: (A3 A2 A1)2 A3 being the M.S.B

1
Boolean (switching) Algebra

Operator name Function symbol

AND x  y = xy

OR x+ y

NOT (Inverter) x' = x

NAND x  y = ( x  y )'

NOR x  y = ( x + y )'

Exclusive-OR XOR x  y = xy '+ x' y

Exclusive-NOR XNOR
xy = xy + x' y '
(Equivalence)

Axioms and Theorems:

The Axioms Theorems
(A1) x=0 if x≠1 (A1’) x=1 if x≠0 (T1) x+0 = x (T1’) x1 = x Identities

(A2) If x=0 then x’=1 (A2’) If x=1 then x’=0 (T2) x+1 = 1 (T2’) x  0 = 0 Null elements

(A3) 0  0 = 0 (A3’) 1 + 1 = 1 (T3) x+x = x (T3’) x  x = x Idempotency

(A4) 1  1 = 1 (A4’) 0 + 0 = 0 (T4) (x’)’ = x Involution

(A5) 0  1 = 1  0 = 0 (A5’) 1 + 0 = 0 + 1 =1 (T5) x+x’ = 1 (T5’) x  x’ = Complements

Theorems Theorems
(T6) x+y=y+x (T6’) xy=yx Commutativity
(T11) xy + x’z + yz = xy + x’z Consensus
(T7) (T7’)(xy)z=x(yz) Associativity
(T11') (x+y)(x’+z)(y+z) = (x+y)(x’+z)
(x+y)+z=x+(y+z)
(T8) (T8’) Distributivity (T12) x + x + … + x = x Generalized idempotency
xy+xz=x(y+z) (x+y)(x+z)=x+yz
(T9) x+xy=x (T9’) x(x+y)=x Covering (T12’) x  x  …  x = x

(T10) xy+xy’=x (T10’) Combining

DeMorgan’s Theorems
(x+y)(x+y’)=x

(T13) (x1  x2 … xn)’ = x1’+ x2’+…xn’

(T13’) (x1+x2+… +xn)’ = x1’  x2’  …  xn’

2
 3-variable minterms and Maxterms:

minterm maxterm
x’y’z’ m0 x+y+z M0
x’y’z m1 x+y+z’ M1
x’yz’ m2 x+y’+z M2
x’yz m3 x+y’+z’ M3
xy’z’ m4 x’+y+z M4
xy’z m5 x’+y+z’ M5
xyz’ m6 x’+y’+z M6
xyz m7 x’+y’+z’ M7

K-Map Horizontal Configuration (MSB - rows, LSB - columns) – Notation we used in class
B C

A A B
B C A

K-Map Vertical Configuration (MSB - columns, LSB - rows) D

Combinational circuits
Half Adder – a circuit that implements binary addition; it outputs the sum and carry
of two input bits: C = xy , S = x y
Full Adder – a circuit that implements binary addition; it outputs the sum and carry
of carry input and two input bits: Cout = xy + Cin ( x + y ) = xy + Cin ( x  y ) , S = x  y  Cin

Carry-Look-Ahead – advanced method of performing addition in parallel without having to "wait" for

the carry to ripple through the system.

3
Sequential Circuits – Flip Flops
Excitation Table Functional / Truth Table Characteristic Equation , Symbol

Qn Qn +1 S R S R Qn +1 Qn+1 SR
0 0 Qn Qn
0 0 0 d
Qn+1=S+R 'Qn
0 1 1 0 0 1 0 1

1 0 0 1 1 0 1 0 S Q

1 1 d 0 1 1 1* 1*
R Q

Qn Qn +1 J K Qn +1 Qn+1 JK-FF
J K
0 0 0 d Qn Qn
0 0
Qn+1=J·Qn'+K'·Qn
0 1 1 d
0 1 0 1
1 0 d 1 J Q
1 0 1 0
1 1 d 0 K
1 1 Qn Qn
‫שעון‬ Cp CLR Q

Qn Qn +1 D D Qn +1 Qn+1 D-FF
0 0 0 0 0 1
Qn+1=D
0 1 1 1 1 0

1 0 0 D Q

1 1 1
‫שעון‬ Cp CLR Q

T-FF
Qn Qn +1 T T Qn +1 Qn+1
0 0 0 0 Qn Qn Qn+1=T·Qn'+T '·Qn
0 1 1
1 Qn Qn T 
1 0 1
1 1 0 ‫שעון‬ Cp 

(‫ )סופיא‬CLR

4
Sequential Circuits – state machines

Generic tracking system

block diagram
X1 Z1
XL ZM
Combinational Logic
◼ X : input variables
◼ Y : input to
system’s memory
(= D Flip-Flops)
y1
D
Y1 ◼ y : state variables
◼ Z : output variables
y2
D
Y2 (functions)

yk Yk
D

FSM synthesis process

◼ Draw the state diagram (states A,B,C…)
◼ Write the transition table
◼ Choose a state variable assignment method, and assign
FFs accordingly
(e.g. 8 states => 3 FFs: Q2 Q1 Q0 , binary assigned)
◼ Re-write the transition table using the state values
(Q2Q1Q0) instead of the state names (A,B,C…)
◼ Choose the FF types (D, JK, …) and recall its excitation
table
◼ Write the excitation & output table for the FSM
◼ From it, find the excitation & output functions
◼ Minimize them, and draw the synthesized sequential
circuit.

FSM analysis process

• Examine the given sequential circuit
• Find the equations describing the next state function Q*= F(Q,X)
and the output function Z= G(Q,X)
• Use F and G to build the transition table
(= the n.s. and output per each possible combination of c.s. and input)
• Draw the state diagram.

5
6
Definitions
Number systems
Decimal number – base/radix 10
Binary, Octal, Hexadecimal numbers - base/radix 2, base/radix 8, base/radix 16
A number may contain an integer part and a fraction part.
Bit – binary digit
Byte - 8 bits
LSb – least significant bit – the rightmost bit
MSb – most significant bit – the leftmost bit
Unsigned – a binary number with no sign
Signed – a binary number which includes sign information
Two's complement (2's complement, 2C) number representation method
Overflow – occurs when an operation result strays from the representation range.

Codes
(Binary) Word – a string of bits
Codeword – a (binary) word that belongs to a certain code
Code – (a translation of a group of words to) a group of codewords
BCD code – binary coded decimal – each decimal digit is coded by its binary value.
Weighted code – each bit in the codeword has a certain weight, used in the calculation of the value of
this digit.
EXCESS-3 code – results from BCD code by adding 0011 to every codeword.
k-of-n code – a code with n-bit codewords, where exactly k bits out of n are '1'.
Cyclic code – a code in which every pair of adjacent codewords differs in only one bit.
Alpha-numeric code – a characters representation code
ASCII code – a specific type of alpha-numeric code.
Error detection – detecting that an error has occurred in a word
Error correction – detecting the location of the error within the word, such that this bit location can be
corrected (by inverting this bit).
Distance between two codewords – the number of different bits between the two words.
Code distance – the minimal distance between any two codewords of this code.
Parity check – adding a bit to each codeword, such that the total number of '1's in the augmented
codeword will become an even number. i.e. if the parity of the codeword alone is odd then the parity bit
will be '1', else if the parity of the codeword is even then the parity bit will be '0'.
Unary operator – a rule that maps a single element to each single element.

E.g. the NOT (negation) operator: x' x ,

7
Binary operator – a rule the maps a single element to each pair of elements. E.g. the OR (union)
operator: x+y , xy ; the AND operator: xy , xy , xy .
Duality – exchanging each '1' with '0' , each '0' with '1' , each AND with OR,
each OR with AND. (no exchange of positive/negated literals!)
Duality principle – Any theorem or identity in switching algebra remains true
if 0 and 1 are swapped and  and + are swapped throughout.
Binary variable – a variable that can accept only '1' or '0'.
Primed variable – the complement of the variable (= the variable after NOT operation: x')
Literal – a variable or a primed variable.
Boolean function of n variables – a rule that maps a binary result to each possible combination of values
of these n variables.
Truth table (functional table) – a table showing all the possible results for a Boolean function (for all
combination of values of its n variables)
Complementing function – the negation of the function result.
Complete set – a set (group) of operators, by which any Boolean function can be realized.
Standard Product – minterm – an expression where all the function's n variables are ANDed together,

each variable appears as is or primed. Convention: m0 ,..., m2n

Standard Sum – Maxterm – an expression where all the function's n variables are ORed together, each

variable appears as is or primed. Convention: M 0 ,..., M 2n

SOP – sum of products
POS – product of sums
Standard SOP mi + m j + ... + mk =  (i, j..., k )

Standard POS M p  M q  ...  M r =  ( p, q,..., r )

Canonical form – writing the function as a standard SOP or as a standard POS.

Canonical form for function containing Don't Care (d, X, ) combinations:
F ( x1 ,..., xn ) =  (i, j..., k ) + d (l ,..., m) =  (i, j..., k ) +   (l ,..., m)

or
F (x1 ,..., xn ) =  ( p, q,..., r ) • d (l ,..., m) =  ( p, q,..., r ) •   (l ,..., m)

Karnaugh Maps method – useful for finding a minimal/compact expression for a function
of up to 6 variables.
Implicant; Prime Implicant (PI); Essential PI (EPI)
Parity checker – a circuit that counts the number of 1's in its input, and outputs even / odd.
Comparator; Arithmetic comparator