Error detection is a method that allows some sommunications erros to be detected. The data is encoded so that the encoded data contains additional redundant information about the data. The data is decoded so that the additional redundant information must match the original information. This allows some errors to be detected. Unfortunately, some error bursts may cause incorrectly received blocks which pass the error detection test. Therefore, good error detection schemes are designed so that this should occur as infrequently as possible.

Parity checking

Parity checking is a primitive character-based error detection method. The characters are encoded so that an additional bit is added to each character. The additional bit is to 0 or 1 according to the number of bits set in the character. The resulting number is either even or odd. There extra bit is set according to this result and according to which parity setting, either even or odd, is being used. If even parity is used, the extra bit is always set so that the codeword always contains an even number of bits set. In even parity, the number of bits set in the codeword is always odd. The decoding is done simply by checking the codeword and removing the extra bit. The parity checking will only detect one bit error bursts in each codeword. Parity checking has been used in character-based terminals but it is not useful for today’s reliable communications. However, it is being used in memory chips to ensure correct operation.

Block check

Block check is a block-based error detection method. The data is divided in blocks in the encoding process. An additional block check is added to each block of data. The check is calculated from the current block. The receiver also performs the same calculation on the block and compares the calculated result with the received result. If these checks are equal the blocks are likely to be valid. Unfortunately, the problem with all block checks is that the block check is shorter than than the block. Therefore, there are several different blocks that all have the same checksum. It is possible that the date is corrupted by a random error burst that modifies the block contents so that the block check in the corrupted frame also matches the corrupted data. In this case the error is not detected. Even best block checks cannot detect all error bursts but good block checks mimimize this propability. However, the reliability increases as the length of the block check increases.

1 Block check sum

Block check sum is a primitive block check sum that is the sum of all characters in the block. The result is a character that is equally long as the characters in the block. Therefore, the result is sometimes referred as the block check character (BCC). Unfortunately, even a long BCC may allow relatively simple errors. In other words, it is easy to find different blocks that generate the same block check sum. Calculating check sum is certainly fast and easy but the reliability of the check sum is not adequate for today’s reliable communications. However, due to its speed it is used in some applications which require that the calculation is done by the software. [6]

2 Cyclic redundancy check

The Cyclic redundancy check (CRC) is an intelligent alternative for block check sum. It is calculated by dividing the bit string of the block by a generator polynomial. The value of the cyclic redundancy check is the reminder of the calculation which is one bit shorter than the generator polynomial. This value is also sometimes referred as the frame check sequence (FCS). However, the generator polynomial must be chosen carefully. CRC is a stronger check than the block check sum and it is being used in today’s reliable communication. Calculating the CRC requires slighty more processing than the check sum. It can be easily implemented by using shift registers and xor-operations both in hardware and software implementations. The most common CRC is the CCITT CRC-16. The CRC is able to detect all single error bursts up to the number of bits in the CRC and most random errors [6]. Unfortunately, the error bursts in many applications are random and the CRC can only find only most of them. Therefore, a random error burst on the block might sometimes match both the original and the corrupted data. This is the case especially when CRC-16 is being used. Therefore, the number of bits in the checksum should be as high as possible or at least high enough. CRC-32 is enough for many todays applications. It has been tested that as the number of bits in the CRC increases the propability that two different blocks with the same CRC are encountered during the data transmission approaches zero [4]. The test results show that the even CRC-48 can be enough to ensure than no two different blocks having the same CRC can be found in practice [4].