# comm.CRCGenerator System object

Package: comm

Generate CRC code bits and append to input data

## Description

The `CRCGenerator` object generates cyclic redundancy code (CRC) bits for each input data frame and appends them to the frame. The input must be a binary column vector.

To generate cyclic redundancy code bits and append them to the input data:

1. Define and set up your CRC generator object. See Construction.

2. Call `step` to generate cyclic redundancy code (CRC) bits for each input data frame according to the properties of `comm.CRCDetector`. The behavior of `step` is specific to each object in the toolbox.

## Construction

`H = comm.CRCGenerator` creates a cyclic redundancy code (CRC) generator System object™, `H`. This object generates CRC bits according to a specified generator polynomial and appends them to the input data.

`H = comm.CRCGenerator(Name,Value)` creates a CRC generator object, `H`, with each specified property set to the specified value. You can specify additional name-value pair arguments in any order as (`Name1`,`Value1`,...,`NameN`,`ValueN`).

`H = comm.CRCGenerator(POLY,Name,Value)` creates a CRC generator object, `H`. This object has the `Polynomial` property set to `POLY`, and the other specified properties set to the specified values.

## Properties

`Polynomial`

Generator polynomial

Specify the generator polynomial as a binary or integer row vector, with coefficients in descending order of powers, or as a polynomial string. The default is `'z^16 + z^12 + z^5 + 1'`. If you set this property to a binary vector, its length must equal the degree of the polynomial plus `1`. If you set this property to an integer vector, its value must contain the powers of the nonzero terms of the polynomial. For example, ```[1 0 0 0 0 0 1 0 1]``` and `[8 2 0]` represent the same polynomial, $g\left(z\right)={z}^{8}+{z}^{2}+1$. The following table lists commonly used generator polynomials.

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

`InitialConditions`

Initial conditions of shift register

Specify the initial conditions of the shift register as a scalar or vector with a binary, double- or single-precision data type. The default is `0`. The vector length must equal the degree of the generator polynomial that you specify in the `Polynomial` property. When you specify initial conditions as a scalar, the object expands the value to a row vector of length equal to the degree of the generator polynomial.

`DirectMethod`

Direct method (logical)

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. The default value for this property is `false`.

Refer to the Communications System Toolbox -> System Design -> Error Detection and Correction -> Cyclic Redundancy Check Coding -> CRC Algorithm section to learn more about the direct and non-direct algorithms.

`ReflectInputBytes`

Reflect input bytes

Set this property to true to flip the input data on a bytewise basis prior to entering the data into the shift register. When you set this property to `true`, the input frame length divided by the `ChecksumsPerFrame` property value must be an integer multiple of `8`. The default value of this property is `false`.

`ReflectChecksums`

Reflect checksums before final XOR

When you set this property to `true`, the object flips the CRC checksums around their centers after the input data are completely through the shift register. The default value of this property is `false`.

`FinalXOR`

Final XOR value

Specify the value with which the CRC checksum is to be XORed as a binary scalar or vector. The object applies the XOR operation just prior to appending the input data. The vector length is the degree of the generator polynomial that you specify in the `Polynomial` property. When you specify the final XOR value as a scalar, the object expands the value to a row vector with a length equal to the degree of the generator polynomial. The default value of this property is `0`, which is equivalent to no XOR operation.

`ChecksumsPerFrame`

Number of checksums per input frame

Specify the number of checksums that the object calculates for each input frame as a positive integer. The default is `1`. The integer must divide the length of each input frame evenly. The object performs the following actions:

1. Divides each input frame into `ChecksumsPerFrame` subframes of equal size.

2. Prefixes the initial conditions vector to each of the subframes.

3. Applies the CRC algorithm to each augmented subframe.

4. Appends the resulting checksums at the end of each subframe.

5. Outputs concatenated subframes.

For example, you can set an input frame size to `10`, the degree of the generator polynomial to `3`, `InitialConditions` property set to `0`, and the `ChecksumsPerFrame` property set to `2`. When you do so, the object divides each input frame into two subframes of size `5` and appends a checksum of size `3` to each subframe. In this example, the output frame has a size $10+2×3=16$.

## Methods

 clone Create CRC generator object with same property values getNumInputs Number of expected inputs to step method getNumOutputs Number of outputs from step method isLocked Locked status for input attributes and nontunable properties release Allow property value and input characteristics changes reset Reset states of CRC generator object step Generate CRC code bits and append to input data

## Examples

expand all

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

```msg = randi([0 1],12,1); ```

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

```gen = comm.CRCGenerator([1 0 0 1],'ChecksumsPerFrame',2); codeword = step(gen,msg); ```

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

```detect = comm.CRCDetector([1 0 0 1],'ChecksumsPerFrame',2); [~, err] = step(detect,codeword) ```
```err = 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] = step(detect,codeword) ```
```err = 0 1 ```

### Cyclic Redundancy Check of Noisy BPSK Data Frames

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

```crcGen = comm.CRCGenerator('z4+z3+z2+z+1'); crcDet = comm.CRCDetector('z4+z3+z2+z+1'); ```

Generate 12-bit frames of binary data and append 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 = step(crcGen,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)] = step(crcDet,demodData); % Detect CRC errors end ```

Identify the frames in which bit errors are detected.

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

## Algorithms

This object implements the algorithm, inputs, and outputs described on the CRC-N Generator block reference page. The object properties correspond to the block parameters.