CRC Program in Java

CRC stands for Cyclic Redundancy Check. It was invented by W. Wesley Peterson in 1961. It is an error detecting technique through which we can detect the error in digital networks(or communication channel or digital data) and storage devices. It is used to trace the accidental changes in the digital data. In this section, we will learn how to calculate and perform CRC through a Java program. Let's understand CRC in detail.

CRC Mechanism

It is an error detection mechanism in which a special number is added to the block of data. The primary goal to add the number is to identify the changes during the transmission or storage. It is calculated twice, once at the sender side during the data transmission and recalculated at the receiver side. It compares data bit by bit with originally transmitted values. If any error (corrupted bit) occurs during the transmission of data, the CRC does not match with the originally transmitted value. We can easily understand the CRC mechanism by the following figure.

For example, a single corrupted bit in the data results in a one-bit change in the calculated CRC, but multiple corrupted bits may cancel each other out. If multiple bits are corrupted or changed is known as a burst error.

There is some other error detection mechanism like Vertical Redundancy Check (VRC)and Longitudinal Redundancy Check (LRC), but CRC is more powerful in comparison with others. The algorithm of CRC is more complex because it uses binary division to calculate CRC. The divisor is generated using polynomials. So, CRC is also called polynomial code checksum.

Following are the steps used in CRC for error detection:

In the first step, we append N 0's to the data unit. The value of N is always less than the number of bits in the data unit(referred to as division which is N+1).
In the next step, we use the process of binary division for dividing the newly extended data by a divisor, and the reminder which we get from this division is referred to as CRC remainder.
In the next step, we replace all the 0's which we append before in the data unit with the remainder bits. After that, we sent the newly generated data unit to the receiver.
The receiver receives the data unit with the CRC remainder. After that, the receiver divides the data unit by the divisor.
If the remainder is zero after dividing the data unit with the divisor, unit data is not corrupted and can be accepted.
If the remainder is not equal to zero after dividing the data unit with the divisor, unit data is corrupted and will be discarded.

Let's take an example and understand how CRC works:

Suppose the original data is 11100 and the divisor is 1001.

First, we will add the zeros in the data unit part. The length of the divisor is 4, and we know that the length of the string 0s is always one less from its divisor. So, we append three zeros in the data unit, i.e., 11100.
After appending the zeros, the resultant string will be 11100000, which we divide by the divisor, i.e., 1001. We use the binary division process for dividing data unit by divisor.
The remainder which we get after dividing the data unit by the divisor is referred to as CRC remainder.
CRC remainder replaces the appended string of 0s at the end of the data unit, and the final string would be 11100111, which is sent across the network.

CyclicRedundancyCheck.java

// import required classes and packages
package javaTpoint.MicrosoftJava;
import java.util.*;
// create CRCExample class to demonstrate the working of Cyclic Redundancy Check
class CRCExample {
	// main() method start
	public static void main(String args[]) {
		// create scanner class object to take input from user
		Scanner scan = new Scanner(System.in);
		// declare n for the size of the data
		int size;
		// take the size of the data from the user
		System.out.println("Enter the size of the data array: ");
		size = scan.nextInt();
		// declaration of the data array
		int data[] = new int[size];
		// take bits of the data from the user
		System.out.println("Enter data bits in the array one by one: ");
		for(int i = 0 ; i < size ; i++) {
			System.out.println("Enter bit " + (size-i) + ":");
			data[i] = scan.nextInt();
		}
		// take the size of the divisor from the user
		System.out.println("Enter the size of the divisor array:");
		size = scan.nextInt();
		// declaration of the divisor array
		int divisor[] = new int[size];
		System.out.println("Enter divisor bits in the array one by one: ");
		for(int i = 0 ; i < size ; i++) {
			System.out.println("Enter bit " + (size-i) + ":");
			divisor[i] = scan.nextInt();
		}
	// Divide the input data by the input divisor and store the result in the rem array
		int rem[] = divideDataWithDivisor(data, divisor);
		// iterate rem using for loop to print each bit
		for(int i = 0; i < rem.length-1; i++) {
			System.out.print(rem[i]);
		}
		System.out.println("\nGenerated CRC code is: ");
		
		for(int i = 0; i < data.length; i++) {
			System.out.print(data[i]);
		}
		for(int i = 0; i < rem.length-1; i++) {
			System.out.print(rem[i]);
		}
		System.out.println();
		// we create a new array that contains the original data with its CRC code
		// the size of the sentData array with be equal to the sum of the data and the rem arrays length
		int sentData[] = new int[data.length + rem.length - 1];
		System.out.println("Enter bits in the array which you want to send: ");
		for(int i = 0; i < sentData.length; i++) {
			System.out.println("Enter bit " +(sentData.length - 1)+ ":");
			sentData[i] = scan.nextInt();
		}
		receiveData(sentData, divisor);
	}
	// create divideDataWithDivisor() method to get CRC
	static int[] divideDataWithDivisor(int oldData[], int divisor[]) {
		// declare rem[] array
		int rem[] = new int[divisor.length];
		int i;
		int data[] = new int[oldData.length + divisor.length];
	// use system's arraycopy() method for copying data into rem and data arrays
		System.arraycopy(oldData, 0, data, 0, oldData.length);
		System.arraycopy(data, 0, rem, 0, divisor.length);
		// iterate the oldData and exor the bits of the remainder and the divisor
		for(i = 0; i < oldData.length; i++) {
			System.out.println((i+1) + ".) First data bit is : "+ rem[0]);
			System.out.print("Remainder : ");
			if(rem[0] == 1) {
				// We have to exor the remainder bits with divisor bits
				for(int j = 1; j < divisor.length; j++) {
					rem[j-1] = exorOperation(rem[j], divisor[j]);
					System.out.print(rem[j-1]);
				}
			}
			else {
				// We have to exor the remainder bits with 0
				for(int j = 1; j < divisor.length; j++) {
					rem[j-1] = exorOperation(rem[j], 0);
					System.out.print(rem[j-1]);
				}
			}
			// The last bit of the remainder will be taken from the data
			// This is the 'carry' taken from the dividend after every step
			// of division
			rem[divisor.length-1] = data[i+divisor.length];
			System.out.println(rem[divisor.length-1]);
		}
		return rem;
	}
	// create exorOperation() method to perform exor data
	static int exorOperation(int x, int y) {
		// This simple function returns the exor of two bits
		if(x == y) {
			return 0;
		}
		return 1;
	}
	// method to print received data 
	static void receiveData(int data[], int divisor[]) {
	 
		int rem[] = divideDataWithDivisor(data, divisor);
		// Division is done
		for(int i = 0; i < rem.length; i++) {
			if(rem[i] != 0) {
				// if the remainder is not equal to zero, data is currupted
				System.out.println("Currupted data received...");
				return;
			}
		}
		System.out.println("Data received without any error.");
	}
}

Output: