Leveraging ChatGPT - GenAI as a Microsoft Data Expert

Speaker

Prerita Agarwal

Data Specialist @

23 Jul, 2024 @ 01:30 PM

Introduction

Hey ninjas! You have come across the topic of the CRC program in C.

In C programming, CRC is a way to check if data has errors. It can be done differently and is used in many real-life situations. You must know about the CRC program in C to write good software that doesn't make mistakes

Everything you need to know about CRC (Cyclic Redundancy Check) in C programming language is covered in this article. We'll go through its nature, operation, and application. We'll also discuss some real-world applications for CRC and its various forms. Whether you are a beginner or have some programming experience, this article is ideal if you want to learn the CRC program in C.

A computer program written in C language that uses the CRC algorithm to check for mistakes in data is known as a CRC program in C. This function generates a unique code for the data to check for errors and then compares it to the code received. The CRC program can verify that data is accurate before it is utilized. It typically forms a component of a bigger program.

Connect with our expert counsellors to understand how to hack your way to success

User rating 4.7/5

1:1 doubt support

95% placement record

Akash Pal

Senior Software Engineer

326% Hike After Job Bootcamp

Himanshu Gusain

Programmer Analyst

32 LPA After Job Bootcamp

After Job Bootcamp

Importance of CRC Program in C

The CRC program helps ensure that the data is accurate and reliable. This is crucial since inaccurate data can lead to issues with usage and undermine public confidence in the information by providing that data is correct.

The CRC program in C helps prevent these problems by ensuring the data is precise and trustworthy, meaning people can trust and use the information confidently.

There are numerous real-world uses for the CRC program in C, some of which include:

1. The CRC program in C ensures that the data stored on storage devices like hard drives are accurate and can be retrieved without errors. Data is checked for mistakes when saved on these devices by the CRC program, which also appends a code that can be used to check for faults afterward. The data could be lost or rendered useless if there are any errors. Therefore this is crucial.

2. The CRC program is employed in medical devices like blood pressure and heart monitors to ensure accurate and reliable data.

3. To ensure a digital signature is authentic and hasn't been altered, algorithms employ the CRC program.

C supports several distinct CRC algorithm types. They have names derived from certain polynomial equations. The CRC -8, CRC -16, CRC -32, CRC -CCITT, and CRC -DNP are a few examples. They are utilized in various systems and sectors to check for data transmission and storage faults. The system's needs determine the algorithm to use.

Understanding the Theory Behind CRC

We'll now go over a step-by-step tutorial to assist you in putting a CRC program into practice. This software can be used to find data transfer and storage issues.

The formula used by a program in C to produce a check value is:

Choose a polynomial that generates n degrees.

A generator polynomial should have a degree less than or equal to the length of the data being communicated.

The generator polynomial should not be factorable into smaller polynomials but irreducible.

X16 + X12 + X5 + 1, X32 + X26 + X23 + X22 + X16 + X12 + X11 + X10 + X8 + X7 + X5 + X4 + X2 + X + 1, and X64 + X4 + X3 + X + 1 are a few often used generator polynomials.

2. Each bit of information is represented as a string of 1s and 0s using a procedure to convert it into binary form.

3. Finish the binary data by appending n zeros.

4. Divide the generating polynomial by the binary data (including the added zeros) using binary division.

5. The remainder of the division is the check value.

The generator polynomial is a mathematical formula that will be applied to this message to create a unique check value.

Let's say you want to communicate "NINJA" to someone.

Suppose the message "NINJA" is generated using the polynomial x3 + x2 + 1. The message is converted to binary format before being subjected to the polynomial. This causes a check value of "010".

Transform the string "NINJA" into its ASCII equivalent, which is the decimal value "78 73 78 74 65" or the binary value "01001110 01001001 01001010 01000001".

The binary data should add three zeros because the generating polynomial has a degree of three. "0100111001001010010011101001010001000" is now the binary data.

Divide the binary data (including the appended zeros) by the generator polynomial using binary division:

0100111001001001010011100100101001000 | 1101

The check value, which is "100", is the amount that remains after this division.

2. We then build the transmitted message "NINJA100" by adding this check value ("100") to the original message. The received message "NINJA100" is subjected to the same generating polynomial at the receiving end, producing a check value.

3. It is presumed that the message was transmitted flawlessly if the resulting check value matches the one transferred, in this case, "100".

4. If the check values do not agree, there is a transmission error, and a new transmission of the message is necessary to ensure proper reception.

Implementation of CRC Program in C

This code generates a checksum for a set of data. A checksum is a number used to identify possible transmission or storage issues to confirm the accuracy of the data.

#include <stdio.h>
#include <string.h>
int main()
{
char test[100];
scanf("%s", test);
printf("Test message is %s\n", test);
char csum = 0x00;
char polynomial = 0x07;
int len = strlen(test);
for (int j = 0; j < len; j++)
{
char ch = test[j];
csum = csum^ch;
int i = 0;
while(i <= 7)
{
csum = (csum << 1) ^ ((csum & 0x80) ? polynomial : 0x00);
i++;
}
}
printf("Checksum is %d\n", (int)csum);
return 0;
}

Output

This program creates a checksum for a user-provided input string. A checksum is a number used to determine whether data has been accurately sent or stored.

The checksum is calculated by the code iterating through every character in the input string. The checksum's beginning value is 0x00, while the polynomial's initial value is 0x07. The checksum value is then updated by running an XOR operation between the checksum and each character in the string.

The checksum is left-shifted by 1 bit, and if its most significant bit is set to 1, it is XORed with the polynomial value eight times in a loop.

The code prints out the determined checksum value at the end.

Code for Error Detection

This code receives a message from the user, adds extra zeros to the end, uses a predetermined generating polynomial to compute a CRC code for the message, and then adds the CRC code to the end of the message.

The code then flips a bit to add a random error to the message before calculating the CRC code once more and comparing it to the received CRC code to determine whether it was corrupted. If they match, no error is introduced; otherwise, an error is detected.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
char* calculate(char* mes, const char* gen)
{
int m = strlen(mes);
int n = strlen(gen);
char* message = (char*) malloc((m+n) * sizeof(char));
strcpy(message, mes);
strcat(message, "00000000");
for (int i = 0; i <= m-n; i++)
{
if(message[i]!='0')
{
for (int j = 0; j < n; j++)
{
if(message[i+j] == gen[j])
message[i+j] = '0';
else
message[i+j] = '1';
}
}
}
return message+m;
}
int main()
{
char gen[] = "1011";
char mes[100];
printf("Enter message: ");
scanf("%s", mes);
char* crc = calculate(mes, gen);
char* mesWithCRC = (char*) malloc((strlen(mes)+strlen(crc)+1) * sizeof(char));
strcpy(mesWithCRC, mes);
strcat(mesWithCRC, crc);
char* rmessage = (char*) malloc((strlen(mes)+strlen(crc)+1) * sizeof(char));
strcpy(rmessage, mesWithCRC);
srand(time(0));
int modulo = strlen(mesWithCRC);
int errorIndex = rand() % modulo;
// If the original bit was a 0, it is flipped to 1; otherwise, it is flipped to 0.
if (mesWithCRC[errorIndex] == '0')
{
rmessage[errorIndex] = '1';
}
else
{
rmessage[errorIndex] = '0';
}
char* receivedMessage = (char*) malloc((strlen(mes)+1) * sizeof(char));
strncpy(receivedMessage, rmessage, strlen(mes));
receivedMessage[strlen(mes)] = '\0';
char* receivedCRC = calculate(receivedMessage, gen);
if (strcmp(receivedCRC, rmessage+strlen(mes)) == 0)
{
printf("No error detected!\n");
}
else
{
printf("Error detected.\n");
}
free(crc);
free(mesWithCRC);
free(rmessage);
free(receivedMessage);
return 0;
}

INPUT: 110101

Output

INPUT: 101010

Output

The function char* calculate(char* mes, const char* gen) takes a message (mes) and a generator polynomial (gen) as inputs, computes the message's CRC code, and returns the result as a character pointer.

Determine the input message's length with int m = strlen(mes);.

Find the length of the generator polynomial with int n = strlen(gen);.

char* message = (char*) malloc((m+n) * sizeof(char));: dynamically allocates memory to store the message and CRC code.

strcat(message, "00000000");: appends eight "0" characters to the end of the message.

for (int j = 0; j < n; j++) {: loops through the generator polynomial.

If the current character in the message and the current character in the generating polynomial are equal, the current character is checked, and if true, it is replaced with "0".

else message[i+j] = '1';: replaces the current character in the message with "1" if it is not equal to the current character in the generator polynomial.

int modulo = strlen(mesWithCRC);: calculates the input message length and CRC code.

The dynamically allocated memory previously allocated using the malloc() method is released using the free() function in the code.

How does a CRC program's performance change depending on the choice of CRC polynomial?

The amount of bits utilized to form the CRC code depends on the CRC polynomial, and different polynomials can offer varying degrees of error detection and computing efficiency. Higher-degree polynomials may provide better error detection but slower computation, whereas lower-degree polynomials may provide faster computation but less error detection.

Can you describe the distinction between burst and single-bit errors and how CRC can identify them?

When several bits in a row are damaged simultaneously, or when there is a cluster of faults, it is known as a burst error. The CRC code will differ from the original code in case of a single-bit error, signaling a transmission fault. CRC can identify both faults.

How do you implement a CRC algorithm in C while dealing with endianness and bit-ordering?

Endianness can be handled when creating a CRC method in C by manipulating the data using bitwise operations to achieve the desired endianness. Before processing the incoming data, you can flip the bits around to address bit-ordering.

How do you implement a hardware-accelerated CRC algorithm?

It would be best to use specialized hardware modules optimized for CRC calculations, load data into the module, start the calculation, and retrieve the result to create a CRC algorithm with hardware acceleration. Use specialized instructions or libraries to interface with the hardware by consulting the documentation for that particular piece.

Conclusion

We have discussed a variety of CRC program-related topics in this post. Also, we addressed subjects from beginner to expert levels, including sample codes for the CRC program.

You can consult other articles and resources offering more in-depth information to learn about the CRC program in C.