How to EncodE and dEcodE InformatIon

IT Zone
How to Encode and
Decode Information
Learn to convert between various codes for digital data transmission
• C.T. Bhunia
Digital data is represented,
stored and exchanged in
the form of codes written in
strings of 0’s and 1’s known as bits.
And encoding and decoding is an
art of transforming one representation
into another and vice versa. In
accounts section of offices, employee
codes are used for salary disbursement.
The code is a unique number
given to the employee name. Decoding
is getting the employee details
from the code.
In computer engineering, encoding
and decoding are used for transformation
of numerical data from one
system to another system for specific
use. There are different kinds of binary
codes, like weighted and non-weighted
codes, reflected codes, sequential
codes, alphanumeric codes, and error
detection and correction codes.
Weighted code
Converting decimal data into binary
and vice versa is essential for computing
as the computer realises only
binary data from ‘on’ and ‘off’ states
of the transistor built into the system.
Binary codes are the codes that are
represented in binary system with
modification from the original ones.
There are two such codes: weighted
binary codes and non-weighted
codes.
In addition to conversion of the
number system, it is often desirable to
retain decimal character even when it
is encoded in binary digits, or bits (1
or 0). For example, consider decimal
number 56, where we represent individual
decimal digits, namely, 5 and 6,
as 0101 for 5 and 0110 as 6:
56=01010110
Such a representation is known
as binary-coded decimal (BCD). It is
a code known as weighted code (see
Table I).
From Table I, you can find the code
of 783 as 0111 1000 0011. In fact, each
digit of the decimal number is coded
as 4-tuple binary data, say, a 3
a 2
a 1
a 0 ,
as
follows:
First decimal Second decimal Last decimal
digit digit digit
a 3
a 2
a 1
a 0
a 3
a 2
a 1
a 0
a 3
a 2
a 1
a 0
BCD is also known as 8421 code,
where 8, 4, 2 and 1, respectively, rep-
Table I
Weighted BCD Codes for
Decimal Digits
Decimal digit
BCD code weight
8 4 21
0 0 0 00
1 0 0 01
2 0 0 10
3 0 0 11
4 0 1 00
5 0 1 01
6 0 1 10
7 0 1 11
8 1 0 00
9 0 0 01
resent weights of fourth, third, second
and first positions of the tuple.
As examples of other weighted
codes, Table II shows following codes:
2421, 74-2-1 and 4221.
In fact, weighted binary codes
are those which obey the positional
weighting principle (each position
of the number represents a specific
weight).
Some weighted codes are known
as reflective codes. A code is said to
be reflective when the code for 9 is the
complement for the code for 0, code for
8 is the complement for the code for 1,
and so on. Codes 2421, 5211 and excess-3
are reflective, whereas the 8421
code is not reflective.
Similarly, some weighted codes
are sequential. A code is said to be
sequential when two subsequent
codes, seen as numbers in binary representation,
differ by one. This greatly
aids in mathematical manipulation of
data. The 8421 and Excess-3 codes are
70 • september 2010 • electronics for you www.efymag.com

IT Zone
sequential, whereas the 2421 and 5211
codes are not sequential.
Some features of
weighted codes
Except 8421 and 74-2-1 codes, for all
other weighted codes some of the decimal
number may be coded in more than
one forms. For example, decimal 4 in
2421 code may be represented as 1010
or 0100. That’s why 2421 and 4221 are
known as self-complementing codes.
A property known as self-complementing
is applied to select a code
out of different options. The property
is stated as follows: If ‘D’ is the given
decimal number, you may code it in
any option, but then decimal number
9-D must be coded taking the option
such that the code is bit-wise complement
of the code of D. For example, if
decimal 4 in 2421 is coded as 0100, then
9-4=5 must be coded as 1011. See that
1011 is bit-wise complement of 0100.
We have shown the code in Table
II applying the self-complementing
property. A necessary condition of
self-complementing property is that
the sum of weights in the code is 9.
The codes 8421 and 74-2-1 are not selfcomplementing.
Non-weighted code
In many cases, there may be some
requirement for non-weighted codes
(see Table III), particularly from design
point of view. Non-weighted codes are
codes that are not positionally weighted.
That is, each position within the
binary number is not assigned a fixed
value. The examples of a few nonweighted
codes are excess-3 code, 1-to-
2 code and BCDP (BCD with parity).
Excess-3 is a non-weighted code
used to express decimal numbers. The
code derives its name from the fact that
each binary code is the corresponding
8421 code plus 0011(3).
Some features of nonweighted
code
Excess-3 code is just BCD with plus 3
weight. If ‘d’ is the decimal number,
d+3 is coded in 8421 to get the excess-3
code. This code is the most important
non-weighted code in digital logic design.
1-to-2 code has a unique feature.
No code has less than one and greater
than two 1’s. BCDP (with odd parity) is
designed so as to make any code having
odd numbers of 1’s. This is done
with selection of parity bit, which is the
right-most bit of the code.
Gray code/binary
reflected code
Table II
Weighted Codes
Decimal digit
2421 code 74-2-1 code 4221 code
Weight 2 4 2 1 Weight 7 4 -2 -1 Weight 4 2 2 1
0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 1 0 1 1 1 0 0 0 1
2 0 0 1 0 0 1 1 0 0 0 1 0
3 0 0 1 1 0 1 0 1 0 0 1 1
4 0 1 0 0 0 1 0 0 0 1 1 0
5 1 0 1 1 1 0 1 0 1 0 0 1
6 1 1 0 0 1 0 0 1 1 1 0 0
7 1 1 0 1 1 0 0 0 1 1 0 1
8 1 1 1 0 1 1 1 1 1 1 1 0
9 1 1 1 1 1 1 1 0 1 1 1 1
Decimal digit
Table III
Non-weighted Codes
Excess-3 code
(XS-3 code)
1-to-2 code
Gray code is a very important nonweighted
code. An N-bit gray code is
a sequence of all the N-bit binary numbers,
ordered in such a way that each
binary number differs from its predecessor
and successor by exactly 1 bit
(and the first and last differ by one bit
also). For example, one-bit gray code
0, 1 and three-bit gray
code 000, 001, 011, 010,
110, 111, 101, 100 (differs
from 000 by 1 bit).
The sequence 00, 11, 01,
10 is not a two-bit gray
code as the first and
second elements differ
by two bits.
Table IV shows a
4-bit code in comparison
with a binary number.
In the column of
decimal number, it is
seen that from 00 to 09
if you move from number
N to number N+1,
there is a change in
only one digit. But when you
move from 09 to 10, there are
changes in two digit positions.
Look at the column of reflected
decimal number: as you move
from N to N+1, always there
is change in one digit position.
In binary representation as
we move from N to N+1, there
may be many changes in bits.
For example, as you go from 3
to 4, there are as many as three
changes in bit position. But,
look at the reflected binary or
gray code: as you move from
any N to N+1, always there
is only one change in bit position.
This is the property of gray code
or reflected binary code. Gray code
is also known as a variable weighted
code and is cyclic.
The gray code is called ‘reflected
binary,’ because the first eight values
compare with those of the last eight
values, but in reverse order. The gray
code belongs to a class of codes called
‘minimum change codes,’ in which
only one bit in the code changes when
moving from one code to the next. The
gray code is a reflective digital code
which has a special property that any
two subsequent numbers’ codes differ
by only one bit. It is also called ‘unitdistance
code.’
Gray code has an important application
in digital control systems. Let
BCDP (with
odd parity)
0 0 0 1 1 0 0 0 1 0 0 0 0 1
1 0 1 0 0 0 0 1 0 0 0 0 1 0
2 0 1 0 1 0 0 1 1 0 0 1 0 0
3 0 1 1 0 0 1 0 0 0 0 1 1 1
4 0 1 1 1 0 1 0 1 0 1 0 0 0
5 1 0 0 0 0 1 1 0 0 1 0 1 1
6 1 0 0 1 1 0 0 0 0 1 1 0 1
7 1 0 1 0 1 0 0 1 0 1 1 1 0
8 1 0 1 1 1 0 1 0 1 0 0 0 0
9 1 1 0 1 1 1 0 0 1 0 0 1 1
72 • september 2010 • electronics for you www.efymag.com

IT Zone
Decimal
Table IV
Gray/Reflected Code
Reflected
decimal
Binary
b 3
b 2
b 1
b 0
us take the example of a fan regulator
which is digitally controlled. You want
to switch from position 3 to 4. If you
follow the normal binary system, you
need to change three bit positions to
switch from 3 to 4. But how? Change
three positions one after another as
shown in Table V.
In gray code, there is change in
only one position, so there will be no
oscillation as such. The code is called
reflected because it can be generated
in the following manner: Take the
gray code 0, 1. Write it forwards, then
backwards: 0, 1, 1, 0. Then prepend 0’s
Reflected binary/gray code
g 3
g 2
g 1
g 0
00 00 0000 0000
01 01 0001 0001
02 02 0010 0011
03 03 0011 0010
04 04 0100 0110
05 05 0101 0111
06 06 0110 0101
07 07 0111 0100
08 08 1000 1100
09 09 1001 1101
10 19 1010 1111
11 18 1011 1110
12 17 1100 1010
13 16 1101 1011
14 15 1110 1001
15 14 1111 1000
16 13
17 12
18 11
19 10
Table V
Illustration of Property of Gray Code
to the first half and 1’s to
the second half: 00, 01, 11,
10. Continuing, write 00,
01, 11, 10, 10, 11, 01, 00 to
obtain 000, 001, 011, 010,
110, 111, 101, 100. Each iteration
therefore doubles
the number of codes.
Algorithm for
binary-to-gray
conversion
This is very simple:
1. The most significant
bit of the binary number
is the most significant bit
of the gray code
2. Add (using modulo
2, i.e., ignoring carry)
the next significant bit of
the binary number to the
next significant bit of the
binary number to obtain
the next gray code bit.
3. Repeat step 2 until
all bits of the binary bits
have been added modulo
2. The resultant number is
Present number Action Next number
0011 (=3) Starting position Change in the first position from right 0010 (=2)
0010(=2) Change in the second position from right 0000(=0)
0000(=0) Change in the third position from right 0100(=4) Final position
Comment: So for a change from regulating position 3 to 4, the fan will go a round of 3 to 2 to 0 to 4.
This will cause huge oscillation in the circuit, which is not a good design.
the gray code equivalent of the binary
number.
Assume binary number b 3
b 2
b 1
b 0
= 0011. Conversion into gray is done
as follows: g 3
= b 3 =0; g 2 = b 3 +b 2 =0+0=0;
g 1
=b 2
+b 1
=1+0=1; and g 0
= b 1
+b 0
=1+1=0
(ignore ‘carry’)
Gray-to-binary conversion
Assume gray code g 3
g 2
g 1
g 0
=0010.
It can be converted into binary
as follows: b 3
=g 3
/2=remainder
0; b 2
= [g 3
+g 2
]/2=remainder 0; b 1
=
[g 3
+g 2
+g 1
]/2=remainder 1; b 0
=
[g 3
+g 2
+g 1
+g 0
]/2=remainder 1. Thus
equivalent binary is 0011.
Excess-3 gray code
In many applications, it is desirable
to use a BCD as well as unit distance.
Excess-3 gray code is such a code. The
values for 0 and 9 differ in only one
bit, and so do all values for successive
numbers. Outputs from linear devices
or angular encoders may be coded in
excess-3 gray code to obtain multi-digit
BCD numbers.
The code obtained from excess-3
code by applying conversion rule is
shown below:
Decimal Excess-3 gray code
0 0010
1 0110
2 0111
3 0101
4 0100
5 1100
6 1101
7 1111
8 1110
9 1010
Error correction and
detection codes
When a binary message made of
strings of 0’s and 1’s is transmitted
from the source to the destination,
the message is corrupted by the noise
during transmission. The corrupted
message becomes erroneous by conversion
from transmitted 0 to received 1 or
from transmitted 1 to received 0.
The error-correction code (ECC)
and the error-detection code (EDC)
are used to rectify the errors. In EDCs
and ECCs, redundant check bits are
pended with original message bits to
design the codes. EDCs detect presence
of errors. ECCs detect and correct
the errors.
Typically, transmission errors are
of two types: random and burst. An
error is called random if bits in the
error are randomly distributed over
the code. Burst error occurs when
bits in the error are clustered together
over the code. For transmitted byte
01010101, the examples of random
error and burst error may be as below
www.efymag.com
electronics for you • september 2010 • 73

IT Zone
(underlined bits are in error):
01110111 ---- Random error (errors
are distributed and in second and sixth
bit locations),
and
01101101 ---- Burst error (errors are
clustered on fourth, fifth and sixth bit
locations).
Several EDCs and ECCs are used
to address both random and burst errors.
R.W. Hamming introduced one-bit
error-correcting codes in 1950. (7,4) and
(13,8) are the examples of one-bit ECCs.
P. Elias developed convolution codes in
1955. In 1959, R.C. Bose and D.K. Chaudhuri
proposed multiple error-correcting
codes. These are very powerful codes
and known as generalised Hamming
codes. A. Hocquenghem independently
designed the codes proposed by Bose
and Chaudhuri. That is why these codes
are known as BCH codes. In 1960, I.S.
Reed and G. Solomon designed powerful
block codes particularly for burst
errors, known as Reed Solomon codes.
In 1960, G.D. Fornery introduced the
concept of concatenated codes. In 1967,
A.J. Viterbi introduced an important
convolution code known as Viterbi code.
Turbo code, low-density parity code,
combined turbo code, punctured turbo
code, cyclic redundancy code (CRC)
and Golay code are the other important
codes.
Error detection and correction
codes begin with parity codes. Parity
codes are EDCs. Parity bit is used for
error detection. In parity codes, a parity
bit (either odd or even) is appended
to the original message bits; parity bit
is the redundant check bit. Even parity
bit ensures even number of 1’s in the
code (message plus parity bit). Odd
parity ensures odd number of 1’s in the
code. If an original message of seven
bits is 1110001, its codes with parity
bit are: even parity [11100010] and odd
parity [11100011], where bold bits are
parity bits.
Hamming code is an ECC. Richard
Hamming, a theorist with Bell
Telephone Laboratories in the 1940s,
developed the Hamming code method
of error correction in 1949. The key to
the Hamming code is the use of extra
parity bits to allow identification of the
errors. Hamming code (7,4) can detect
and correct one-bit error, whereas (13,8)
code can detect up to two simultaneous
bit errors, and correct single-bit errors.
A code with this ability to reconstruct
the original message in the presence of
errors is known as the error-correcting
code. By contrast, the simple parity discussed
above cannot correct errors, and
can detect only an odd number of errors.
An ECC always has more check
bits than EDC and hence requires
more bandwidth. In simple parity
check bit is just one, whereas in (7,4)
and (13,8) codes check bits are 3 and
5, respectively. Code capability and
complexity in system design are the
other parameters for selection of a code
for particular applications.
Encoding of (7,4)
Hamming code (7, 4) encodes four
bits of data into seven bit blocks called
‘code word.’ The extra three bits are
parity bits. Each of the three parity bits
maintains even parity for three of the
four data bits, and no two parity bits
are for the same three data bits. If the
four data bits in (7, 4) are d 1
, d 2
, d 3
and
d 4
, Hamming code parity bits p 1
, p 2
and p 3
are calculated as:
p 1
= d 2
+ d 3
+ d 4
p 2
= d 1
+ d 3
+ d 4
p 3
= d 1
+ d 2
+ d 4
where ‘+’ means bit-wise exclusive OR
operation, i.e., sum ignoring carry. For
example, you can encode data 1010
using the Hamming code as 1011010.
Decoding of (7,4)
In a world without errors, decoding a
Hamming code word would be very
easy. Just leave out the parity bits. In
the example of code word, the parity
bits are 101 and when you leave these
out, you will receive data bits as 1010.
But what if you receive a code
word with an error and one or more
of the parity bits are wrong? Suppose
the received code word is 1011011. The
first step is to check the parity bits to
determine whether there is an error.
Calculate parity bits with received
bits as:
p 1
= d 2
+ d 3
+ d 4
= 0 + 1 + 1 = 0
p 2
= d 1
+ d 3
+ d 4
= 1 + 1 + 1 = 1
p 3
= d 1
+ d 2
+ d 4
= 1 + 0 + 1 = 0
In this case, every parity bit is
wrong. p 1
, p 2
and p 3
should have been
010, but you received 101. Compare received
parity bits with these calculated
parity bits to get bit pattern 111. This
bit pattern has decimal value of 7. Now
reverse the bit at seventh position of
the received code to get 1011010, and
then leave out parity bits 101 to receive
the corrected data as 1010.
Generalised Hamming
code for single bit-error
correction
Illustration of (7,4) Hamming code
paves the way for explaining generalised
Hamming code. In generalised
code, coding is done as below:
1. All bit positions that are powers
of 2 will be locations for parity bits in
code words. Thus in code words, locations
of parity bits are 1, 2, 4, 8, 16, 32,
64, etc.
2. All other bit positions are for the
given original data to be encoded. That
means data locations are 3, 5, 6, 7, 9, 10,
11, 12, 13, 14, 15, 17, etc.
3. Each parity bit calculates the
parity for some of the bits in the code
word. The position of the parity bit
determines the sequence of bits that
it alternately checks and skips as follows:
(i) Location 1: check 1 bit, skip 1
bit, check 1 bit, skip 1 bit, etc (1, 3, 5, 7,
9, 11, 13, 15,...), (ii) Location 2: check 2
bits, skip 2 bits, check 2 bits, skip 2 bits,
etc (2, 3, 6, 7, 10, 11, 14, 15,...), (iii) Location
4: check 4 bits, skip 4 bits, check
4 bits, skip 4 bits, etc (4, 5, 6, 7, 12, 13,
14, 15, 20, 21, 22, 23,...), (iv) Location 8:
check 8 bits, skip 8 bits, check 8 bits,
skip 8 bits, etc (8-15, 24-31, 40-47,...), (v)
Location 16: check 16 bits, skip 16 bits,
check 16 bits, skip 16 bits, etc (16-31,
48-63, 80-95,...), (vi) Location 32: check
32 bits, skip 32 bits, check 32 bits, skip
32 bits, etc (32-63, 96-127, 160-191,...).
4. Set a parity bit to 1 if the total
number of 1’s in the positions that it
74 • september 2010 • electronics for you www.efymag.com

IT Zone
checks is odd. Set a parity bit to 0 if the
total number of 1’s in the positions that
it checks is even. This means even parity
is ensured in the code word.
We illustrate with an example.
Say, the original given byte of data is
10011010. As per Hamming code, the
code word will be: _ _ 1 _ 0 0 1 _ 1 0 1
0, where ‘_’ locations are for the parity
for each parity bit.
• Location-1 check bit is 0, as created
by even parity rule of data at locations
1, 3, 5, 7, 9, 11.
• Location-2 check bit is obtained
by even parity rule of data bit locations
2, 3, 6, 7, 10, 11 as 1.
• Location-4 check bit is obtained
from data locations of 4, 5, 6, 7, 12 as
1.
• Location-8 check bit is obtained
from data locations of 8, 9, 10, 11, 12
as 0.
• Thus the code word becomes:
011100101010.
Suppose the received code is
011100101110. Here the error location is
highlighted in bold. The receiver calculates
parity bits from the received data,
and compares calculated parity bits with
received parity bits to find out which bit
is in order to correct it. The method is to
verify all the incorrect parity bits by the
comparison stated. In the example, parity
bits 2 and 8 are incorrect.
It is now 2 + 8 = 10, and that bit position
10 is the location of the incorrect
bit. We complement the tenth bit to get
back the correct code word.
Repetition code
Coding Theory is the study of how to
add redundancy or additional bits to
the original given data so as to use them
to detect and correct errors induced by
the communication channel. Here, the
transmitter sends the data bit several
times, an odd number of times in fact.
In general, if each bit is repeated 2K + 1
(K is a positive integer) times, the code
can tolerate up to K errors.
In repetition code, bit to be transmitted
is transmitted more than once.
In triple repetition code, ‘0’ and ‘1’ are
coded, respectively, as ‘000’ and ‘111’.
At the receiver, majority rule is applied
to decide about the bit. If the three bits
received were not identical, an error
occurred. If the channel is nearly clean,
most likely only one bit will change in
each triple. Therefore 001, 010 and 100
each correspond to a 0 bit, while 110,
101 and 011 correspond to a 1 bit.
Such codes cannot correct all errors.
For example, if the channel introduces
two bits error and the receiver
gets ‘001,’ the system detects the error,
but concludes that the original bit was
0, which is incorrect. If we increase the
number of times we duplicate each bit
to four, we can detect all two-bit errors
but can’t correct; at five, we can correct
all two-bit errors, but not detect all
three-bit errors. •
The author is a regular contributor to EFY
www.efymag.com
electronics for you • september 2010 • 75