COM347J1_L4D 1/13

1
COM347J1/COM552J1Networks and Data Communications
Lecture 4D Further examples of Data encoding for
error detection CRC and Checksums
This presentation Modified late on 30/10/05,
explained CRC division

• Ian McCrum Room 5D03B Web site
  http//www.eej.ulst.ac.uk
• Tel [phone] voice mail on 6th ring Email
  IJ.McCrum_at_Ulster.ac.uk

2
Cyclic Redundancy Codes (CRC)

• The CRC technique is used to protect blocks of
  data called Frames. Using this technique, the
  transmitter appends an extra n- bit sequence to
  every frame called Frame Check Sequence (FCS).
  The FCS holds redundant information about the
  frame that helps the transmitter detect errors in
  the frame. The CRC is one of the most used
  techniques for error detection in data
  communications. The technique gained its
  popularity because it combines three advantages
• Extreme error detection capabilities.
• Little overhead.
• Ease of implementation.

3
Basics

• The basic idea of CRC algorithms is simply to
  treat the message as an enormous binary number,
  to divide it by another fixed binary number, and
  to make the remainder from this division the
  checksum.
• Upon receipt of the message, the receiver can
  perform the same division and compare the
  remainder with the "checksum" (transmitted
  remainder).
• There are a few additional points to bear in
  mind. The fixed binary number is defined in
  advance, although several versions exist.
• The division is done in a simplified way, no
  carries are generated during the subtraction.

• widely used in practice (ATM, HDLC)
• ATM 5-byte header uses 8-bit CRC
• IEEE GCRC-32 , 32-bit CRC for Ethernet, etc.
• Although simple checksums are also used ,they are
  less efficient at detecting errors

4
CRC in Practice

• International standards (CCITT) are defined for
  CRC-8, CRC-12, CRC-16, and CRC-32
• CRC-8 ATM header error control
• CRC-10 ATM AAL error detection (recommended)
• CRC-12 IBM Bisync error control
• CCITT-16 HDLC, XMODEM, V.41
• CCITT-32 IEEE 802, V.42, ATM AAL5
• Each standard CRC can detect
• ALL burst errors of lt r1 bits, and ALL odd
  number of bit errors
• Bursts of gt r1 bits detected with P 1 0.5r

5
Internet checksum (RFC1071)
Goal detect errors (e.g., flipped bits) in
transmitted segment (note in actual practice,
used at transport layer only)

• Receiver
• compute checksum of received segment
• check if computed checksum added to checksum
  field value gives zero
• NO - error detected
• YES - no error detected. But maybe errors
  nonetheless?

• Sender
• treat segment contents as sequence of 16-bit
  integers
• checksum addition (1s complement sum) of
  segment contents
• sender puts checksum value into UDP checksum
  field

6
Cyclic Redundancy Code (CRC)

• CRCs treat a bit string as a polynomial code with
  coefficients of 0 and 1. A k-bit frame is
  regarded as the coefficient list for a polynomial
  of order k, ranging from xk-1 to x0, said to be
  of degree k-1. The leftmost bit is xk-1 the next
  is xk-2
• I.e 110001 has 6 bits and is said to be x5x4x0
  or x5x41
• This is only important because the divisor is
  specified in this way, in practice you convert it
  to a binary number and do calculation using
  binary
• Binary arithmetic is needed but the division
  process is simplified. Subtraction is done
  without carries or borrows and so is actually an
  XOR operation or just a matter of letting a bit
  through or inverting itand when you do the
  subtraction itself is slightly different

7
The polynomial code (optional)

• The transmitter and receiver must agree the
  polynomial code of the generator, normally called
  G(x).
• It will be a binary number that must begin and
  end with a 1. It will have less bits than the
  data being protected
• Basic idea is to add extra bits after the data so
  that the complete new frame is divisible exactly
  by G(x). The receiver does the division and if
  the remainder is zero then all is ok
• We begin with data of m bits represented by M(x).
  Add r bits to this, initially zero in value, r is
  the degree of G(x)
• Since the early bits are zero we have changed
  M(x) to xr M(x)
• We divide xr M(x) by G(x) using module-2 division
  and

8
This example from http//www.relisoft.com/Science
/CrcNaive.html

• The CRC algorithm requires the division of the
  message polynomial by the key polynomial. The
  straightforward implementation follows the idea
  of long division, except that it's much simpler.
  The coefficients of our polynomials are ones and
  zeros. We start with the leftmost coefficient
  (leftmost bit of the message). If it's zero, we
  move to the next coefficient. If it's one, we
  subtract the divisor. Except that subtraction
  modulo 2 is equivalent to exclusive or, so it's
  very simple.
• Let's do a simple example, dividing a message
  100110 by the key 101 also expressed as x2 1.
  Since the degree of the key is 2, we start by
  appending two zeros to our message.
• 1 0 1 ) 1 0 0 1 1 0 0 0
• 1 0 1
• 1 1 1
• 1 0 1
• 1 0 0
• 1 0 1
• 1 0 0
• 1 0 1
• Remainder is 0 1 so transmit 1 0 0 1 1 0 0
  1

9
Book Example fig 3-7/p189
1 1 0 0 0 0 1 0 1
1 1 0 1 0 1 1 0 1 1 0 0 0 0
1 0 0 1 1
Replace these 4 zeros with the remainder
1 0 0 1 1
1 0 0 1 1
1 0 0 1 1
0 0 0 0 1
0 0 0 0 0
0 0 0 1 0
0 0 0 0 0
0 0 1 0 1
G(x)x4x1
0 0 0 0 0
0 1 0 1 1
0 0 0 0 0
1 0 1 1 0
1 0 0 1 1
0 1 0 1 0
0 0 0 0 0
Remainder is 1 1 1 0
1 0 1 0 0
1 0 0 1 1
0 1 1 1 0
0 0 0 0 0
Transmit 11010110111110
1 1 1 0
10
Cyclic Redundancy Code - Example
Q
? T 110110
11
Cyclic Redundancy Code - Generators

• CRC Generators are subject of design and
  standardization. The goal here is to let them
  have strong properties like
• Detect all single and double errors
• Detect all burst of 16 bits and less
• Example generators are
• CRC-8 100000111
• CRC-10 11000110011
• CRC-12 1100000000101
• CRC-16 11000000000000101
• CRC-CCITT (ITU-T) 10001000000100001
• CRC-32 100000100110000010001110110110111

We see why writing e.g CRC-CCITT as x16x15x21
is less error prone!
12
Cyclic Redundancy Code - Advantages

• The capabilities of e.g. CRC-16
• All single errors are detected
• All double errors are detected
• All burst errors of 16 errors in a row are
  detected
• All errors with an odd number of bits
• There are more
• Highly Efficient Codes
• overhead of e.g. CRC-16 Code for a PDU of size
  12000 (1500 bytes) as in Ethernet 0.14

13
Tutorials for Lecture 4D (CRC)
1 Write the bit pattern 10100001 and 1001 as
polynomials
2 What is the result of dividing (modulo-2) the
polynomial x7x51 by the generator polynomial
x31?
3 Using the CRC generator 1001 generate the
data to be transmitted if a data block is
1111000. ( answer 1111000110)
4 What data is sent if a CRC of x4x11 is used
to protect a data block of 110101101? Answer
(1101011011111)