ArtsAutosBooksBusinessEducationEntertainmentFamilyFashionFoodGamesGenderHealthHolidaysHomeHubPagesPersonal FinancePetsPoliticsReligionSportsTechnologyTravel
  • »
  • Home»
  • Home Decorating»
  • Interior Design & Decor

Cyclic redundancy check implementation using C

Updated on September 27, 2011

Cyclic redundency Check

Cyclic Redundency Check

A cyclic redundancy check (CRC) or polynomial code checksum is a hash function designed to detect accidental changes to raw computer data, and is commonly used in digital networks and storage devices such as hard disk drives. A CRC-enabled device calculates a short, fixed-length binary sequence, known as the CRC code or just CRC, for each block of data and sends or stores them both together. When a block is read or received the device repeats the calculation; if the new CRC does not match the one calculated earlier, then the block contains a data error and the device may take corrective action such as rereading or requesting the block be sent again, otherwise the data is assumed to be error free (though, with some small probability, it may contain undetected errors; this is the fundamental nature of error-checking).

CRCs are so called because the check (data verification) code is a redundancy (it adds zero information to the message) and the algorithm is based on cyclic codes. The term CRC may refer to the check code or to the function that calculates it, which accepts data streams of any length as input but always outputs a fixed-length code. CRCs are popular because they are simple to implement in binary hardware, are easy to analyze mathematically, and are particularly good at detecting common errors caused by noise in transmission channels. The CRC was invented by W. Wesley Peterson in 1961; the 32-bit polynomial used in the CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975.

A CRC is an error-detecting code. Its computation resembles a polynomial long division operation in which the quotient is discarded and the remainder becomes the result, with the important distinction that the polynomial coefficients are calculated according to the carry-less arithmetic of a finite field. The length of the remainder is always less than the length of the divisor (called the generator polynomial), which therefore determines how long the result can be. The definition of a particular CRC specifies the divisor to be used, among other things.

Although CRCs can be constructed using any finite field, all commonly used CRCs employ the finite field GF(2). This is the field of two elements, usually called 0 and 1, comfortably matching computer architecture. The rest of this article will discuss only these binary CRCs, but the principles are more general.

An important reason for the popularity of CRCs for detecting the accidental alteration of data is their efficiency guarantee. Typically, an n-bit CRC, applied to a data block of arbitrary length, will detect any single error burst not longer than n bits (in other words, any single alteration that spans no more than n bits of the data), and will detect a fraction 1−2n of all longer error bursts. Errors in both data transmission channels and magnetic storage media tend to be distributed non-randomly making CRCs' properties more useful than alternative schemes such as multiple parity checks.

The simplest error-detection system, the parity bit, is in fact a trivial 1-bit CRC: it uses the generator polynomial x+1.

Cyclic redundancy check using C

//Program to add crc check bit

#define N strlen(g)

char t[28],cs[28],g[]="10001000000100001";
int a,e,c;

void xor(){
	for(c = 1;c < N; c++)
	cs[c] = (( cs[c] == g[c])?'0':'1');

void crc(){

int main()
	printf("\nEnter data : ");
	printf("\nGeneratng polynomial : %s",g);
	printf("\nModified data is : %s",t);
	printf("\nChecksum is : %s",cs);
	printf("\nFinal codeword is : %s",t);
	printf("\nTest error detection 0(yes) 1(no)? : ");
			printf("\nEnter the position where error is to be inserted : ");
		}while(e==0 || e>a+N-1);
		printf("\nErroneous data : %s\n",t);
	for(e=0;(e<N-1) && (cs[e]!='1');e++);
			printf("\nError detected\n\n");
			printf("\nNo error detected\n\n");
		return 0;


	gcc -ggdb crc.c
	rm a.out *~

Example output

Enter data : 1101

Generatng polynomial : 10001000000100001
Modified data is : 11010000000000000000
Checksum is : 1101000110101101
Final codeword is : 11011101000110101101
Test error detection 0(yes) 1(no)? : 0

Enter the position where error is to be inserted : 2

Erroneous data : 10011101000110101101

Error detected



    0 of 8192 characters used
    Post Comment

    • profile image

      deepthi lavanya 5 weeks ago

      Can you give the decimal data that should be converted into binary data. Then it should perform CRC.

      Can you modify the code in that manner?

    • profile image

      harsha 4 years ago

      in the testing condition after erroneous data error detected is repeated 12 times and if no error is present it displays error

    • profile image

      ajaz ahmed 5 years ago

      nice programing logic