errors
DESCRIPTION
Errors. Transmission errors are a way of life. In the digital world an error means that a bit value is flipped. An error can be isolated to a single bit. Errors on some media come in bursts Harder to detect and correct than isolated errors. Dealing with Errors. Error detecting codes - PowerPoint PPT PresentationTRANSCRIPT
04/20/23 Errors 1
Errors
• Transmission errors are a way of life.
• In the digital world an error means that a bit value is flipped.
• An error can be isolated to a single bit.
• Errors on some media come in bursts– Harder to detect and correct than isolated
errors.
04/20/23 Errors 2
Dealing with Errors
• Error detecting codes– provide enough redundant information to enable the
receiver to deduce that an error occurred
• Error correcting codes– provide enough redundant information to enable the
receiver to deduce that an error occurred AND how to fix it
• So a message consists of m data bits and r redundant or check bits.
04/20/23 Errors 3
Hamming Distance
• Hamming distance:– the number of bit positions in which two codewords
differ
• Simple to calculate find the XOR• If two codewords are a Hamming distance d apart,
it will require d single-bit errors to convert one into the other.
• The Hamming distance of a code is the minimum Hamming distance between any two codewords.
04/20/23 Errors 4
Hamming Distance 2 Code
000011101110
Note that not all of the 8 different bit patterns are included in the code
Any single error will convert a valid codeword into an invalid codeword.
If we know the valid codewords we can detect the error
04/20/23 Errors 5
How Error Detection Works
Invalid Code Words
Validcodeword
Validcodeword
2e
04/20/23 Errors 6
Parity
• A simple single error detecting code could be constructed by counting bits.– Any codeword with an even number of bits is consider
valid (you could also make it the other way around).
• The minimum distance of this code is 2, so it is capable of detecting single errors.
• This code can be created by adding a parity bit:– chose the parity bit so that the number of ones in the
codeword is even (or odd).
04/20/23 Errors 7
Parity in ActionData With Parity Bit00 00001 10110 11011 011
Want to send: 10
Data Link Sends: 110 Receive: 111 (ERROR)
04/20/23 Errors 8
Protecting Blocks
• The probability of detecting a burst error on a block using a single parity bit is 50%.
• This can be improved by viewing the block as a n by k bit matrix.
• A parity bit is then computed for each column.• The check bits are placed in a k-bit row and
affixed to the matrix as the last row.• Bursts of length n can be detected.
04/20/23 Errors 9
Detecting Burst Errors10010000110000111101101111011011110100101101110111001111010000011100011011011110110010011100101011001001
100100011000011101101110110111010011101110110011101000001100011110111111001001100101
?
Data
VRC (Vertical Redundancy Check)
LRC (Longitudinal Redundancy Check)
n
04/20/23 Errors 10
What About Error Correction?
• How do we get error correction?– Must increase the minimum distance of the
code
• The key to error correction is that it must be possible to detect and locate the error.
• The minimum distance must be at least 2e+1
04/20/23 Errors 11
Error Correction
Validcodeword
Validcodeword
Invalid codewords
The +1 ensures the circles will not overlap
04/20/23 Errors 12
A Simple Single Error Correcting Code
Data Send Received0 000 000
001010100
1 111 011101110111
04/20/23 Errors 13
Hamming Codes
• Hamming codes are n-bit codes that can correct single errors.
• The basic idea is to split the codeword into two portions– information or message bits (m)– parity bits (k)
• The result are codewords that consist of m+k bits
04/20/23 Errors 14
Choosing m and k
• Selecting m is easy, you are usually told what it is.• How do you pick k?• The parity bits are used to generate a k-bit word
that identifies where in the codeword the error, if any, occurred.
• Consequently, k must satisfy the following:
12 kmk
04/20/23 Errors 15
Constructing the Codeword
• The codeword consists of m+k bits.
• The location of each of the m+k bits is assigned a decimal value, 1 is assigned to the MSB, and m+k to the LSB.
• Parity bits go in positions 1, 2, 4, …, 2k-1
1 2 43 5 876 ... m+k9
p0 p1 m0 p2 m1 m2m3 p3 m4 ... mm+k
04/20/23 Errors 16
Parity Checks
• The parity checks must be specified so that when an error occurs, the position number will take on the the value assigned to to location of the error
Error Position Position Number0 (no error) 0001 0012 0103 0114 1005 1016 1107 111
04/20/23 Errors 17
Putting It TogetherPosition 1
p02p1
3m0
4p2
5m1
6m2
7m3
Original Message 0 1 0 0
Parity check in positions1,3,5,7 requires p0=1
1 0 1 0 0
Parity check in positions2,3,6,7 requires p1=0
1 0 0 1 0 0
Parity check in positions4,5,6,7 requires p2=1
1 0 0 1 1 0 0
04/20/23 Errors 18
ExampleSend the message 0010 using a hamming code
Step 1: Find k. Here k=3
Step 2: Determine where things go
Step 3: Figure out the parity bitsp1 will cover 1,3,5,7,9,11,…p2 will cover 2,3,6,7,10,11,…p3 will cover 4,5,6,7,12,13,14,15,...
04/20/23 Errors 19
Correcting Burst Errors
• Hamming codes can be used to correct burst errors• A sequence of s consecutive codewords are
arranged as a matrix, one codeword per row.• Transmit data one column (s bits) at a time.• The matrix is reconstructed by the receiver one
column at a time.• If a burst error of size s occurs, only a single
column will be affected.
04/20/23 Errors 20
Correcting Burst Errors
001100100001011100100111101010101111010101010110101100101101010110011110011111001100000011111000011101010111111111100110000111000101
100100011000011101101110110111010011101110110011101000001100011110111111001001100101
HammIng
code
Character ASCII Check Bits
s
04/20/23 Errors 21
Correcting vs. Detecting
• Most often error detection followed by retransmission is more efficient.
• Consider a channel with an error rate is 10-6 per bit (one error per million bits sent)– Block size 1000 == 10 check bits ( k == 10 )– For parity one check bit will suffice
• Overhead for sending 1MB– Hamming == 10,000 bits– Parity == 2001 bits (since 1 block will be
retransmitted)
04/20/23 Errors 22
Checksums
• Both sides agree on a checksum function
• Sender– Computes checksum while sending message– Attaches result to the end of the message
• Receiver– Computes checksum while reading message– Compares result to checksum at end of message
04/20/23 Errors 23
Error Detection
04/20/23 Errors 24
Basic Idea
• Treat the entire message as a binary number
• To calculate the checksum– Divide message by another fixed number– Use the remainder as the checksum
• CRC treats bit strings as representations of polynomials with coefficients of 0 and 1.
– 110001 == x5+ x4+ x0
04/20/23 Errors 25
The Generator Polynomial
• Both the sender and the receiver must agree upon a generator polynomial, G(x).– Both the high and low order bits of the
generator must be 1.– The length of the generator is one bit longer
than the FCS.– Finally the frame must be longer than the
generator.
• This is what we use mathematicians for
04/20/23 Errors 26
Standard Polynomials
• CRC-12 (x12+x11+x3+x2+x1+1)– used when the character length is 6
• CRC-16 (x16+x15+x2+1)• CRC-CCITT (x16+x12+x5+1)
– used for 8 bit characters
– catches all single and double errors
– all errors of an odd length
– all bursts of 16-bits or less, 99.997% of 17-bits, and 99.998% of 18-bits and longer.
04/20/23 Errors 27
The Algorithm
• To compute the checksum– Append n 0s to the end of the message, where n
is the number of bits in the checksum– The resulting value is divided by the generator
polynomial– Each division step is carried out in the
conventional manner, except that we use polynomial arithmetic
04/20/23 Errors 28
Polynomial Arithmetic
1 1 0 0-1 -0 -1 -0-- -- -- -- 0 1 1 0
1 1 0 0+1 +0 +1 +0-- -- -- -- 0 1 1 0
• Subtraction and addition as usual but no borrows or carries
• Both operations are identical to XOR
04/20/23 Errors 29
Polynomial Arithmetic
• Addition and subtraction, are a single operation, that is its own inverse
• By collapsing addition and subtraction, the arithmetic discards any notion of magnitude– Beyond the power of the highest bit
• 1010 is clearly greater than 10• 1010 is no longer greater than 1001
– 1010 = 1001 + 0011– 1010 = 1001 - 0011
04/20/23 Errors 30
Polynomial Multiplication
1101 x 1011 ---- 1101 11010 000000 1101000 ------- 1111111
04/20/23 Errors 31
Polynomial Division 1101
1011 1111111
1011
1001
1011
1011
1011
0
04/20/23 Errors 32
The Algorithm (continued)
• The division produces a quotient which is discarded.
• The remainder replaces the 0s appended to the frame (subtracted from the frame modulo 2).
• The resulting frame is now evenly divisible by the generator polynomial.
• The receiver performs the same division, a non-zero remainder indicates that an error occurred.
04/20/23 Errors 33
CRC Example (transmit)
Frame contents: 111011Polynomial: 11101 (x4+ x3+x2 + x0)Frame with 0s: 1110110000
10000111101 1110110000 11101 ----- 10000 11101 ----- 1101
Frame to send: 1110111101
04/20/23 Errors 34
CRC Example (receive)
Frame contents: 1110111101Polynomial: 11101 (x4+ x3+x2 + x0)
10000111101 1110111101 11101 ----- 11101 11101 ----- 0
04/20/23 Errors 35
Fast Polynomial DivisionStart 0000000 1111111 0000000
Shift 0000001 1111110 0000000
Shift 0000011 1111100 0000000
Shift 0000111 1111000 0000000
Shift 0001111 1110000 0000000
XOR/Inc 0000100 1110000 0000001
Shift 0001001 1100000 0000010
XOR/Inc 0000010 1100000 0000011
Shift 0000101 1000000 0000110
Shift 0001011 0000000 0001100
XOR/Inc 0000000 0000000 0001101
04/20/23 Errors 36
Optimize
• For CRC– We do not need the quotient– If the divisor is W bits long
• The remainder will be at most W-1 bits long
• Only need 1 register
04/20/23 Errors 37
Faster Polynomial DivisionStart 000 1111111
Shift 001 111111
Shift 011 11111
Shift 111 1111
Shift 1 111 111
XOR 100 111
Shift 1 001 11
XOR 010 11
Shift 101 1
Shift 1 011
XOR 000
04/20/23 Errors 38
CRC Simple Version
• Consider the polynomial 10111 with a CRC of size W=4• To perform the division perform the following:
– Load the register with zero bits. – Augment the message by appending W zero bits to the end of it. – While (more message bits)
• Shift the register left by one bit, reading the next bit of the augmented message into register bit position 0.
• If (a 1 bit popped out of the register during step 3) – Register = Register XOR Poly.
• The register contains the remainder.
Source: http://www.repairfaq.org/filipg/LINK/F_crc_v33.html