comm.RaisedCosineReceiveFilter

Filter the output of a square-root-raised-cosine (RRC) transmit filter by using a matched RRC receive filter. The input signal has eight samples per symbol.

Create an RRC transmit filter object, setting the number of output samples per symbol to 8.

 txfilter = comm.RaisedCosineTransmitFilter('OutputSamplesPerSymbol',8);

Create an RRC receive filter, setting the number of input samples per symbol to 8 and the decimation factor to 8.

rxfilter = comm.RaisedCosineReceiveFilter('InputSamplesPerSymbol',8, ...
    'DecimationFactor',8);

Use the coeffs function to determine the filter coefficients for both filters.

txCoef = coeffs(txfilter);
rxCoef = coeffs(rxfilter);

Display the magnitude responses of the two filters. The results show that the responses are the same. Here we use the freqz and plot functions to plot the magnitude responses. The Filter Analyzer app can also generate the filter responses.

[htx,f] = freqz(txfilter);
hrx = freqz(rxfilter);

plot(f/pi,mag2db(abs([htx hrx])))
ylabel("Magnitude (dB)")
xlabel("Normalized Frequency (\times\pi rad/sample)")
legend(["Tx" "Rx"]+" Filter")
grid
ylim([-65 15])

Generate a random bipolar signal. Interpolate the signal by using the RRC transmit filter object.

 preTx = 2*randi([0 1],100,1) - 1;
 y = txfilter(preTx);

Decimate the signal by using the RRC receive filter object.

 postRx = rxfilter(y);

The filter delay is equal to the filter span. Accounting for the filter delay, adjust the plotted samples to compare the pre-Tx filter signal with the post-Rx filter signal. Because the combined receive and the transmit RRC filters generate a matched filter pair, the two signals overlap one another.

delay = txfilter.FilterSpanInSymbols;
x = (1:(length(preTx)-delay));
plot(x,preTx(1:end-delay),x,postRx(delay+1:end))
legend('Pre-Tx filter','Post-Rx filter')

Decimate a bipolar signal using a square-root-raised-cosine (RRC) filter whose impulse response is truncated to filter a span of six symbol durations.

Create a RRC transmit FIR filter, setting the filter span to six symbols. The object truncates the impulse response to six symbols.

txfilter = comm.RaisedCosineTransmitFilter(FilterSpanInSymbols=6);

Generate a random bipolar signal. Filter the signal by using the RRC transmit FIR filter object.

x = 2*randi([0 1],25,1) - 1;
y = txfilter(x);

Create a matched RRC receive filter object.

rxfilter = comm.RaisedCosineReceiveFilter(FilterSpanInSymbols=6);

Use impz to plot the impulse response of the receive filter.

impz(rxfilter)

Filter the output signal from the transmit filter by using the matched RRC receive filter object.

r = rxfilter(y);

Plot the interpolated signal. The results show a delay equal to the filter span (six symbols) before data passes through the filter.

stem(r)

Create a square-root-raised-cosine (RRC) receive filter object. Use freqz to plot the filter response. The results show that the linear filter gain is greater than unity. Specifically, the passband gain is more than 0 dB.

rxfilter = comm.RaisedCosineReceiveFilter;
freqz(rxfilter)

Use the coeffs object function to obtain the filter coefficients and adjust the filter gain to unit energy.

b = coeffs(rxfilter);

Because a filter with unity passband gain must have filter coefficients that sum to 1, set the linear filter gain to the inverse of the sum of the filter tap coefficients, b.Numerator.

rxfilter.Gain = 1/sum(b.Numerator);

Verify that the resulting filter coefficients sum to 1.

bNorm = coeffs(rxfilter);
sum(bNorm.Numerator)

ans = 
1.0000

Plot the filter frequency response. The results now show that the passband gain is 0 dB, which is unity gain.

freqz(rxfilter)