# Use Forward Error Correction on 16-QAM Signal

This example extends the Use Pulse Shaping on 16-QAM Signal example to show bit error rate (BER) performance improvement when using forward error correction (FEC) coding.

This example shows how to process a binary data stream by using a communications link that consists of a baseband modulator, channel, demodulator, pulse shaping, raised cosine filtering, and error correction.

### Establish Simulation Framework

In this example, to achieve a more accurate BER estimate, the number of bits to process is increased from the value used in the Use Pulse Shaping on 16-QAM Signal example. Other simulation variables match the settings in that example.

Define simulation parameters for a 16-QAM modulation scheme with raised cosine filtering and an AWGN channel.

```M = 16; % Modulation order k = log2(M); % Bits per symbol numBits = k*2.5e5; % Total bits to process sps = 4; % Samples per symbol (oversampling factor) filtlen = 10; % Filter length in symbols rolloff = 0.25; % Filter rolloff factor```

### Generate Random Data

Set the `rng` function to its default state, or any static seed value, so that the example produces repeatable results. Then, use the `randi` function to generate random binary data.

```rng default; % Use default random number generator dataIn = randi([0 1],numBits,1); % Generate vector of binary data```

### Apply Convolutional Encoding

To correct errors arising from the noisy channel, apply convolutional coding to the data before transmission and Viterbi decoding to the received data. The decoder uses a hard decision algorithm, which means each received data bit is interpreted as either `0` or `1`.

Define a convolutional coding trellis for a rate 2/3 code by using the `poly2trellis` function. The defined trellis represents the convolutional code that the `convenc` function uses for encoding the binary vector, `dataIn`.

```constrlen = [5 4]; % Code constraint length genpoly = [23 35 0; 0 5 13] % Generator polynomials```
```genpoly = 2×3 23 35 0 0 5 13 ```
```tPoly = poly2trellis(constrlen,genpoly); codeRate = 2/3;```

Encode the input data by using the `tPoly` trellis.

`dataEnc = convenc(dataIn,tPoly);`

### Modulate Data

Use the `bit2int` function to convert the `k`-tuple encoded binary data to an integer values.

`dataSymbolsIn = bit2int(dataEnc,k);`

Use the `qammod` function to apply 16-QAM modulation.

`dataMod = qammod(dataSymbolsIn,M);`

### Apply Raised Cosine Filtering

Use the `rcosdesign` function to create an RRC filter.

`rrcFilter = rcosdesign(rolloff,filtlen,sps);`

Use the `upfirdn` function to upsample the signal by the oversampling factor and apply the RRC filter. The `upfirdn` function pads the upsampled signal with zeros at the end to flush the filter. Then, the function applies the filter.

`txSignal = upfirdn(dataMod,rrcFilter,sps,1);`

### Apply AWGN Channel

Using the number of bits per symbol (`k`) and the number of samples per symbol (`sps`), convert the ratio of energy per bit to noise power spectral density (`EbNo`) to an SNR value for use by the `awgn` function. When converting the ${\mathit{E}}_{\mathrm{b}}/{\mathit{N}}_{0}$ to SNR, you must account for the number of information bits per symbol. With no FEC applied, each symbol corresponded to `k` bits. With FEC applied, each symbol corresponds to (`k` $×$ `codeRate`) information bits. For the 2/3 code rate and 16-QAM transmissions used in this example, three symbols correspond to 12 coded bits and 8 uncoded (information) bits.

```EbNo = 10; snr = EbNo+10*log10(k*codeRate)-10*log10(sps);```

Pass the filtered signal through an AWGN channel.

`rxSignal = awgn(txSignal,snr,'measured');`

Filter the received signal by using the RRC filter. Remove a portion of the signal to account for the filter delay.

```rxFiltSignal = ... upfirdn(rxSignal,rrcFilter,1,sps); % Downsample and filter rxFiltSignal = ... rxFiltSignal(filtlen + 1:end - filtlen); % Account for delay```

Use the `qamdemod` function to demodulate the received filtered signal.

`dataSymbolsOut = qamdemod(rxFiltSignal,M);`

### Apply Viterbi Decoding

Use the `int2bit` function to convert the recovered integer symbols into binary data.

`codedDataOut = int2bit(dataSymbolsOut,k); % Return data in column vector`

Use the `vitdec` function, configured for hard decisions and continuous operation mode, to decode the convolutionally encoded data. The continuous operation mode maintains the internal state when the decoder is repeatedly invoked, such as when receiving frames of data operating in a loop. The continuous operation mode also adds delay to the system. Although this example does not use a loop, the '`cont`' mode is used for the purpose of illustrating how to compensate for the delay in this decoding operation.

```traceBack = 16; % Decoding traceback length numCodeWords = ... floor(length(codedDataOut)*2/3); % Number of complete codewords dataOut = ... vitdec(codedDataOut(1:numCodeWords*3/2), ... tPoly,traceBack,'cont','hard'); % Decode data```

### Compute System BER

The delay introduced by the transmit and receive RRC filters is already accounted for in the recovered data, but the decoder delay is not accounted for yet. The continuous operation mode of the Viterbi decoder incurs a delay with a duration in bits equal to the traceback length, `traceBack`, times the number of input streams at the encoder. For the 2/3 code rate used in this example, the encoder has two input streams, so the delay is 2×`traceBack` bits. As a result, the first 2×`traceBack` bits in the decoded vector, `dataOut`, are zeros. When computing the BER, discard the first 2×`traceBack` bits in `dataOut` and the last 2×`traceBack` bits in the original vector, `dataIn`.

Use the `biterr` function to compute the number of errors and the BER by comparing `dataIn` and `dataOut`. For the same ${\mathit{E}}_{\mathrm{b}}/{\mathit{N}}_{0}$ of 10 dB, less errors occur when FEC is included in the processing chain.

```decDelay = 2*traceBack; % Decoder delay, in bits [numErrors,ber] = ... biterr(dataIn(1:end - decDelay),dataOut(decDelay + 1:end)); fprintf('\nThe bit error rate is %5.2e, based on %d errors.\n', ... ber,numErrors)```
```The bit error rate is 4.30e-05, based on 43 errors. ```