# comm.CRCDetector

Detect errors in input data using CRC

## 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.

## 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.```

example

````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

expand all

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.

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 x3+ z2+ 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 z3 + z2 + 1.

Some commonly used generator polynomials include:

CRC methodGenerator 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'`
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 7 + z 2 + 1.

Data Types: `double` | `char`

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`

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`

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`

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`

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`

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)``
``[msg,err] = crcdetector(codeword)``

### Description

example

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

example

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

### Input Arguments

expand all

Received codeword, specified as a binary column vector.

Data Types: `double` | `logical`

### Output Arguments

expand all

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.

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)`

expand all

 `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

collapse all

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 ```

Use a CRC code to detect frame errors in a noisy BPSK signal.

Create a CRC generator and detector pair using a standard CRC-4 polynomial, ${z}^{4}+{z}^{3}+{z}^{2}+z+1$.

```poly = 'z4+z3+z2+z+1'; crcgenerator = comm.CRCGenerator(poly); crcdetector = comm.CRCDetector(poly);```

Generate 12-bit frames of binary data and append the CRC bits. Based on the degree of the polynomial, 4 bits are appended to each frame. Apply BPSK modulation and pass the signal through an AWGN channel. Demodulate and use the CRC detector to determine if the frame is in error.

```numFrames = 20; frmError = zeros(numFrames,1); for k = 1:numFrames data = randi([0 1],12,1); % Generate binary data encData = crcgenerator(data); % Append CRC bits modData = pskmod(encData,2); % BPSK modulate rxSig = awgn(modData,5); % AWGN channel, SNR = 5 dB demodData = pskdemod(rxSig,2); % BPSK demodulate [~,frmError(k)] = crcdetector(demodData); % Detect CRC errors end```

Identify the frames in which CRC code bit errors are detected.

`find(frmError)`
```ans = 6 ```

expand all

## 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.