FCS and CRC difference

can someone explain me the most simple definition, analogy of CRC and FCS

As I understand it the Frame Check Sequence (FCS) is the last 4 bytes in the Ethernet frame and it contains a checksum that the receiving system uses to prove that the rest of the frame has not been corrupted. The mathematical method that is used to generate and check the FCS is a Cyclical Redunancy Check (CRC). Both terms are loosely used to talk about the same thing, the checksum block at the end of the frame, but I believe FCS is the strictly correct name for it

nnbnbWhat TheBishop said is mostly correct but I'm going to try to re-summarize for clarity anyways.

A checksum is a result of an algorithm used for verifying a computation or transmission.

CRC - Cyclical Redunancy Check is a checksum type. It uses a specific algorithm (found below) for checking computation or transmission integrity.

( en.wikipedia.org/wiki/Computation_of_CRC )


FCS - Frame Check Sequence is the process of using an algorithm or many algorithms to check frames.
(*Note: FCS is NOT CRC. While most frame check sequences may use CRC specifically Frame Check Sequence is not the only frame check includes more then just CRC and is not the only option for checking a frame. Non 802.3 (ethernet frames) have the option of using other frame checking methods)






Those definitions aside here is a quick example of how a checksum works:

1. Take data. (in this case a number)

1010111001001010101001

2. Preform math on the number. ( in this case modulo by 4 bytes)

1010111001001010101001 % 1111111111111111111111111111

2855593 % 16777215 = 2855593

(2855593 is not reduced by 16777215 and therefore is a full remainder of itself... if 2855593 was bigger then 16777215 then the modulo process would actually do something)

3. Send/Store/transpose the data

4. Check data by running sent/stored/Transposed through the same algorithm as the check some then it should match the checksum.

2855593 % 16777215 = 2855593
vs

12855593 % 16777215 = 12855593





So lets try this with a number bigger then the checksum


1. Data
12922


2. Preform math on the number. (modulo of %
12923 % 7 = 0000 00101 (3)

(btw modulo is remainder of so the math that is being done here is 12923 divided by 7 = 12920 remainder 3)

3. Send/Store/transpose the data

4. Check data by running sent/stored/Transposed through the same algorithm as the check some then it should match the checksum.

12923 is the original number

12922 is the result after being sent

Preform math on the new data
12922 % 8= 0000 0010

compare result to checksum

0000 0010 != 0000 0101 != stands for not equal to

If results are not the same the check fails. In this case a bit was flipped. A key to take away from this is with most checksum algorithms the more bits used in the check the more reliable the data will be.

For example a 1 bit modulo algorithm will not catch an error 50% of the time.