CRC THE PROJECT COMPLETE DOC

This coding presents realizing high speed hardware for parallel CRC checksums.
Starting from the serial implementation --widely reported in literature, we have identified
a recursive formula from which our parallel implementation is derived.--the new scheme
is faster and more compact and is independent of the technology used in its realization. In
our solution,-- the number of bits processed in parallel can be different from the degree of
the polynomial generator. Lastly, we have --also developed high level parametric codes
that are capable of generating the circuits autonomously, when only the
--polyonomial is given.
--IN THIS PAPER WE HAVE DONE THE CODING ON THE BASIS OF MANUAL
CALCULATION LET ME TELL U THE STEPS FOR APPROACH,BASICALL--TO
KNW ABT CRC FIRST,--CRC stands for Cyclic Redundancy Check. Which means that
is based on cyclic algorithm that generates redundant information.--The CRC performs a
mathematical calculation on a block of data and returns information (number) about the
contents and --organization of that data. So the resultant number uniquely identifies that
block of data. This unique number can be used --to check the validity of data or to
compare two blocks. So this approach is used in many communication and computer
systems--to ensure the validity of the transmitted or stored data. In general CRC codes
are able to detect: All single- and double-bit—errors .All odd numbers of errors. All burst
errors less than or equal to the degree of the polynomial used. Most burst errors--greater
than the degree of the polynomial used.--The main idea of CRC is to treat the message as
binary numbers, and divide it by fixed binary number. The remainder from this--division
is considered the checksum. The recipient of the message performs the same division and
compare the remainder with the --"checksum" (transmitted remainder).As stated in the
previous section, the CRC is a simple binary division and subtraction. The –only
difference is that these operations are done on modulo arithmetic based on mod 2. For
example the addition and subtraction--are replaced with XOR operation that do the sum
and subtraction without carry.--The CRC algorithm uses the term polynomial to perform
all of its calculations. This polynomial is the same concept as the traditional --arithmetic
polynomials. The divisor, dividend, quotient, and remainder that are represented by
numbers are represented as polynomials --with binary coefficients

.-For example the number 23 (10111b) can be represented in the polynomial form as:
--1*x4 + 0*x3 + 1*x2 + 1*x1 + 1*x0
--x4 + x2 + x1 + x0
--Note the binary representation of the number (10111).This representation simplifies the
traditional arithmetic operations (addition,--multiplication, etc…) that are all done on
normal algebraic polynomials. If we can assume that X is 2, then the operations are
simplified--more and some because some terms can be canceled. For example the term
3*x3 is represented as 24 in normal number representation and 24 = 16+8 which is x4+x3
in polynomial representation.--The transmitter can append zeros to the end of the
message (LSB), perform the division and find the remainder and appended it to the
original message.
--The message receiver can do one of the followings:
--Separate the message and checksum. Calculate the checksum for the message (after
appending zeros) and compare the two checksums.
--Checksum the whole message including the CRC (without appending zeros) and check
if the new CRC comes out as Zero.--In real world the serial approach (bit-by-bit)
calculation is not acceptable for many applications that requires high performance or the
-- smallest processing word size is more than a bit For that reason parallel
implementation is needed.--Parallel implementation can be done by entering the data
word to the CRC and perform the serial shift and xor ing the bits in parallel. Simply --it
calculates all xor combinations as if a single bit shifting is done on the data and CRC
register.--now when we come to the coding part we need to form the T MATRIX then we
need to form thr D matrix and the we need to multiply the D and T form the value M --so
this process is a recursively way is goes on repeating again and again and the data is
stored in an array so now here we have used the generic concept --as it is more
advantageous. a nd we have formed the T matrix by taking an empty array initializing
with zeros first and by using the condition we have formed the --T matrix as the T matrix
will be in the identity matrix diagonal will be filled by ones and next we need to form the
D MATRIX this matrix is formed by taking first --as the d matrix first row ,now we need
to compare that T's first row with the each bit is either 0 or 1 if it si one do xor
operation ,by this way we need to put the condition and form a D matrix ,now next is the
formation of both multiplication with the given msg data by the user ..and this is done by
taking the first column of d matrix and then we --need to take T's first column and take
another variable temp which is initially 0's and now see the T's first column if it contains
1 then this temp of single bit individually --perform the xor operation with the D's first
column of a single single bit. .and the result is in turn stored in an array and xor with the
given msg data( input data) and the value --is stored in an an aray that data when when
attached to u r msg bit and do the division with the polynomial then we get the result as
0's so we can clearly say there are no errors if --in case there is an error then we say there
is some error ... by this way the CRC runs and detect the errors....