comm.CRCDetector

Detect errors in input data using CRC

comm.CRCDetector will be removed in a future release. Use crcDetect instead. (since R2024b) For information on updating your code, see Version History.

Description

The comm.CRCDetector System object™ computes cyclic redundancy check (CRC) checksums for an entire received codeword. For successful CRC detection in a communications system link, you must align the property settings of the comm.CRCDetector System object with the paired comm.CRCGenerator System object. For more information, see CRC Syndrome Detector Operation.

To detect errors in the received codeword containing CRC sequence bits:

1. Create the comm.CRCDetector object and set its properties.

2. Call the object with arguments, as if it were a function.

To learn more about how System objects work, see What Are System Objects?

Creation

Syntax

crcdetector = comm.CRCDetector

crcdetector = comm.CRCDetector(Name,Value)

crcdetector = comm.CRCDetector(poly,Name,Value)

Description

crcdetector = comm.CRCDetector creates a CRC code detector System object. This object detects errors in the received codewords according to a specified generator polynomial.

crcdetector = comm.CRCDetector(Name,Value) sets properties using one or more name-value pairs. For example, comm.CRCDetector('Polynomial','z^16 + z^14 + z + 1') configures the CRC code detector System object to use the CRC-16 cyclic redundancy check bits when checking for CRC code errors in the received codewords. Enclose each property name in quotes.

crcdetector = comm.CRCDetector(poly,Name,Value) creates a CRC code detector System object. This object has the Polynomial property set to poly, and the other specified properties set to the specified values.

Properties

Unless otherwise indicated, properties are nontunable, which means you cannot change their values after calling the object. Objects lock when you call them, and the release function unlocks them.

If a property is tunable, you can change its value at any time.

For more information on changing property values, see System Design in MATLAB Using System Objects.

Polynomial — Generator polynomial

'z^16 + z^12 + z^5 + 1' (default) | polynomial character vector | binary row vector | integer row vector

Generator polynomial for the CRC algorithm, specified as one of the following:

• A polynomial character vector such as 'z^3 + z^2 + 1'.

• A binary row vector that represents the coefficients of the generator polynomial in order of descending power. The length of this vector is (N+1), where N is the degree of the generator polynomial. For example, [1 1 0 1] represents the polynomial x³+ z²+ 1.

• An integer row vector containing the exponents of z for the nonzero terms in the polynomial in descending order. For example, [3 2 0] represents the polynomial z³ + z² + 1.

For more information, see Representation of Polynomials in Communications Toolbox.

The default value is the CRC-16-CCITT generator polynomial. This table lists some commonly used generator polynomials.

CRC Name	Generator Polynomial
CRC-32	'z^32 + z^26 + z^23 + z^22 + z^16 + z^12 + z^11 + z^10 + z^8 + z^7 + z^5 + z^4 + z^2 + z + 1'
CRC-24	'z^24 + z^23 + z^14 + z^12 + z^8 + 1'
CRC-16	'z^16 + z^15 + z^2 + 1'
CRC-16-CCITT	'z^16 + z^12 + z^5 + 1'
Reversed CRC-16	'z^16 + z^14 + z + 1'
CRC-8	'z^8 + z^7 + z^6 + z^4 + z^2 + 1'
CRC-4	'z^4 + z^3 + z^2 + z + 1'

Example: 'z^7 + z^2 + 1', [1 0 0 0 0 1 0 1], and [7 2 0] represent the same polynomial, p(z) = z ⁷ + z ² + 1.

Data Types: double | char

InitialConditions — Initial states of internal shift register

0 (default) | 1 | binary row vector

Initial states of the internal shift register, specified as a binary scalar or a binary row vector with a length equal to the degree of the generator polynomial. A scalar value is expanded to a row vector of equal length to the degree of the generator polynomial.

Data Types: logical

DirectMethod — Use direct algorithm for CRC checksum calculations

false (default) | true

Use direct algorithm for CRC checksum calculations, specified as false or true.

When you set this property to true, the object uses the direct algorithm for CRC checksum calculations. When you set this property to false, the object uses the non-direct algorithm for CRC checksum calculations.

For more information on direct and non-direct algorithms, see Error Detection and Correction.

Data Types: logical

ReflectInputBytes — Reflect input bytes

false (default) | true

Reflect input bytes, specified as false or true. Set this property to true to flip the received codeword on a bytewise basis before entering the data into the shift register.

When you set this property to true, the received codeword length divided by the value of the ChecksumsPerFrame property must be an integer and a multiple of 8.

Data Types: logical

ReflectChecksums — Reflect checksums before final XOR

false (default) | true

Reflect checksums before final XOR, specified as false or true. Set this property to true to flip the CRC checksums around their centers after the received codeword is completely through the shift register.

When you set this property to true, the object flips the CRC checksums around their centers before the final XOR.

Data Types: logical

FinalXOR — Final XOR

0 (default) | binary scalar | binary vector

Final XOR, specified as a binary scalar or a binary row vector with a length equal to the degree of the generator polynomial. The XOR operation runs using the value of the FinalXOR property and the CRC checksum before comparing with the input checksum. A scalar value is expanded to a row vector of equal length to the degree of the generator polynomial. A setting of 0 is equivalent to no XOR operation.

Data Types: logical

ChecksumsPerFrame — Number of checksums calculated

1 (default) | positive integer

Number of checksums calculated for each received codeword frame, specified as a positive integer. for more information, see CRC Syndrome Detector Operation.

Data Types: double

Usage

Syntax

out = crcdetector(codeword)

[out,err] = crcdetector(codeword)

Description

out = crcdetector(codeword) checks CRC code bits for each received codeword frame, removes the checksums, and then concatenates subframes to the output frame.

[out,err] = crcdetector(codeword) also returns the checksum error signal computed when checking CRC code bits for each codeword subframe.

Input Arguments

codeword — Received codeword

binary column vector

Received codeword, specified as a binary column vector.

This object accepts variable-size inputs. After the object is locked, you can change the size of each input channel, but you cannot change the number of channels. For more information, see Variable-Size Signal Support with System Objects.

Data Types: double | logical

Output Arguments

out — Output frame

binary column vector

Output frame, returned as a binary column vector that inherits the data type of the input signal. The message word output contains the received codeword with the checksums removed.

The length of the output frame is n - k * r bits, where n is the size of the received codeword, k is the number of checksums per frame, and r is the degree of the generator polynomial.

err — Checksum error signal

binary column vector

Checksum error signal, returned as a binary column vector that inherits the data type of the input signal. The length of Err equals the value of ChecksumsPerFrame. For each checksum computation, an element value of 0 in err indicates no checksum error, and an element value of 1 in err indicates a checksum error.

Object Functions

To use an object function, specify the System object as the first input argument. For example, to release system resources of a System object named obj, use this syntax:

release(obj)

Common to All System Objects

step	Run System object algorithm
release	Release resources and allow changes to System object property values and input characteristics
reset	Reset internal states of System object

Examples

CRC Detection of Errors in a Random Message

Pass binary data through a CRC generator, introduce a bit error, and detect the error using a CRC detector.

Create a random binary vector.

x = randi([0 1],12,1);

Encode the input message frame using a CRC generator with the ChecksumsPerFrame property set to 2. This subdivides the incoming frame into two equal-length subframes.

crcgenerator = comm.CRCGenerator([1 0 0 1],'ChecksumsPerFrame',2);
codeword = crcgenerator(x);

Decode the codeword and verify that there are no errors in either subframe.

crcdetector = comm.CRCDetector([1 0 0 1],'ChecksumsPerFrame',2);
[~, err] = crcdetector(codeword)

err = 2×1

     0
     0

Introduce an error in the second subframe by inverting the last element of subframe 2. Pass the corrupted codeword through the CRC detector and verify that the error is detected in the second subframe.

codeword(end) = not(codeword(end));
[~,err] = crcdetector(codeword)

err = 2×1
     0
     1

Algorithms

Direct and Indirect CRC Algorithm

The comm.CRCDetector System object supports generation and detection of CRC checksum by using the indirect or direct CRC algorithm.

Indirect CRC Algorithm

The indirect CRC algorithm accepts a binary data vector, corresponding to a polynomial M, and appends a checksum of r bits, corresponding to a polynomial C. The concatenation of the input vector and the checksum then corresponds to the polynomial T = M×x^r + C, since multiplying by x^r corresponds to shifting the input vector r bits to the left. The algorithm chooses the checksum C so that T is divisible by a predefined polynomial P of degree r, called the generator polynomial.

The algorithm divides T by P, and sets the checksum equal to the binary vector corresponding to the remainder. That is, if T = Q×P + R, where R is a polynomial of degree less than r, the checksum is the binary vector corresponding to R. If necessary, the algorithm prepends zeros to the checksum so that it has length r.

The CRC generation feature, which implements the transmission phase of the CRC algorithm, does the following:

1. Left shifts the input data vector by r bits and divides the corresponding polynomial by P.

2. Sets the checksum equal to the binary vector of length r, corresponding to the remainder from step 1.

3. Appends the checksum to the input data vector. The result is the output vector.

The CRC detection feature computes the checksum for its entire input vector, as described above.

The CRC algorithm uses binary vectors to represent binary polynomials, in descending order of powers. For example, the vector [1 1 0 1] represents the polynomial x³ + x² + 1.

Bits enter the linear feedback shift register (LFSR) from the lowest index bit to the highest index bit. The sequence of input message bits represents the coefficients of a message polynomial in order of decreasing powers. The message vector is augmented with r zeros to flush out the LFSR, where r is the degree of the generator polynomial. If the output from the leftmost register stage d(1) is a 1, then the bits in the shift register are XORed with the coefficients of the generator polynomial. When the augmented message sequence is completely sent through the LFSR, the register contains the checksum [d(1) d(2) . . . d(r)]. This is an implementation of binary long division, in which the message sequence is the divisor (numerator) and the polynomial is the dividend (denominator). The CRC checksum is the remainder of the division operation.

Direct CRC Algorithm

This block diagram shows the direct CRC algorithm.

Where Message Block Input is $$m_0,m_1,\mathrm{...},m_{k-1}$$ and Code Word Output is

$$c_0,c_1,\mathrm{...}\text{}\text{},\text{}{c}_{n-1}=\underset{X}{\underbrace{m_0,m_1,\mathrm{...}\text{}\text{},m_{k-1},}}\underset{Y}{\underbrace{d_0,d_1,\mathrm{...},d_{n-k-1}}}$$

The initial step of the direct CRC encoding occurs with the three switches in position X. The algorithm feeds k message bits to the encoder. These bits are the first k bits of the code word output. Simultaneously, the algorithm sends k bits to the linear feedback shift register (LFSR). When the system completely feeds the kth message bit to the LFSR, the switches move to position Y. Here, the LFSR contains the mathematical remainder from the polynomial division. These bits are shifted out of the LFSR and they are the remaining bits (checksum) of the code word output.

CRC Syndrome Detector Operation

The CRC syndrome detector outputs the received message frame and a checksum error vector according to the specified generator polynomial and number of checksums per frame.

The checksum bits are removed from each subframe so that the resulting output frame length is N – C×P, where N is the length of the received codeword column, C is the number of checksums per frame, and P is the degree of the generator polynomial. The input frame must be evenly divisible by C.

For a specific initial state of the internal shift register:

1. The received codeword is divided into C equal-sized subframes.

2. The CRC is removed from each of the C subframes and compared to the checksum calculated on the received codeword subframes.

3. The output frame is assembled by concatenating the subframe bits of the C subframes and then output as a column vector.

4. The checksum error is output as a binary column vector of length C. An element value of 0 indicates an error-free received subframe, and an element value of 1 indicates an error occurred in the received subframe.

For the scenario shown here, a 16-bit codeword is received with an error in the third bit, a z³ + z² + 1 generator polynomial computes the CRC checksum, the initial state is 0, and the number of checksums per frame is 2.

Since the number of checksums per frame is 2 and the generator polynomial degree is 3, the received codeword is split in half and two checksums of size 3 are computed, one for each half of the received codeword. The initial states are not shown because an initial state of [0] does not affect the output of the CRC algorithm. The output frame contains the concatenation of the two halves of the received codeword as a single vector of size 10. The checksum error signal output contains a 2-by-1 binary frame vector whose entries should match the transmitted checksum. As shown in the figure, the first checksum differs from the transmitted values and the second checksum matches the transmitted values. This indicates an error occurred in reception of the first half of the codeword.

References

[1] Sklar, Bernard. Digital Communications: Fundamentals and Applications. Englewood Cliffs, N.J.: Prentice-Hall, 1988.

[2] Wicker, Stephen B. Error Control Systems for Digital Communication and Storage. Upper Saddle River, N.J.: Prentice Hall, 1995.

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

See System Objects in MATLAB Code Generation (MATLAB Coder).

Version History

R2024b: To be removed

The comm.CRCDetector System object will be removed. Use an input CRC configuration that you define in a crcConfig data object and the crcDetect function instead.