comm.CoarseFrequencyCompensator

Compensate for frequency offset of PAM, PSK, or QAM signal

Description

The comm.CoarseFrequencyCompensator System object™ compensates for the frequency offset of received signals using an open-loop technique.

To compensate for the frequency offset of a PAM, PSK, or QAM signal:

Create the comm.CoarseFrequencyCompensator object and set its properties.
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

coarseFreqComp = comm.CoarseFrequencyCompensator

coarseFreqComp = comm.CoarseFrequencyCompensator(Name,Value)

Description

coarseFreqComp = comm.CoarseFrequencyCompensator creates a coarse frequency offset compensator System object. This object uses an open-loop technique to estimate and compensate for the carrier frequency offset in a received signal. For more information about the estimation algorithm options, see Algorithms.

coarseFreqComp = comm.CoarseFrequencyCompensator(Name,Value) specifies properties using one or more name-value arguments. For example, Modulation='QPSK' specifies quadrature phase-shift keying modulation.

example

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.

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

`Modulation` — Modulation type
`'QAM'` (default) | `'8PSK'` | `'BPSK'` | `'OQPSK'` | `'PAM'` | `'QPSK'`

Modulation type, specified as one of,

'BPSK' – Binary phase shift keying
'QPSK' – Quadrature phase shift keying
'OQPSK' – Offset quadrature phase shift keying
'8PSK' – 8-phase shift keying
'PAM' – Pulse amplitude modulation
'QAM' – Quadrature amplitude modulation

Data Types: char | string

`Algorithm` — Algorithm used to estimate frequency offset
`'FFT-based'` (default) | `'Correlation-based'`

Algorithm used to estimate the frequency offset, specified as 'FFT-based' or 'Correlation-based'.

Dependency

To enable this property, set Modulation to 'BPSK', 'QPSK', '8PSK', or 'PAM'. This table shows the valid combinations of the modulation type and the estimation algorithm.

Modulation	FFT-Based Algorithm	Correlation-Based Algorithm
`BPSK`, `QPSK`, `8PSK`, `PAM`	Yes	Yes
`OQPSK`, `QAM`	Yes	No

Use the correlation-based algorithm for HDL implementations and for other situations in which you want to avoid using an FFT.

Data Types: char | string

`FrequencyResolution` — Frequency resolution
`100` (default) | positive scalar

Frequency resolution for the offset frequency estimation in hertz, specified as a positive scalar. This property establishes the FFT length used to perform spectral analysis and must be less than the sample rate.

Data Types: double

`MaximumFrequencyOffset` — Maximum measurable frequency offset
`5e3` (default) | positive scalar

Maximum measurable frequency offset in hertz, specified as a positive scalar.

The value of this property must be less than f_samp / M. For more details, see Correlation-Based Estimation.

Dependency

To enable this property, set the Algorithm property to 'Correlation-based'.

Data Types: double

`SampleRate` — Sample rate
`1e6` (default) | positive scalar

Sample rate in samples per second, specified as a positive scalar.

Data Types: double

`SamplesPerSymbol` — Samples per symbol
`4` (default) | even integer, greater than or equal to `4`

Samples per symbol, specified as an even positive integer greater than or equal to 4.

Dependency

To enable this property, set Modulation to 'OQPSK'.

Usage

Syntax

y = coarseFreqComp(x)

[y,estimate] = coarseFreqComp(x)

Description

y = coarseFreqComp(x) returns a signal that compensates for the carrier frequency offset of the input signal.

example

[y,estimate] = coarseFreqComp(x) returns a scalar estimate of the frequency offset.

example

Input Arguments

expand all

`x` — Input signal
column vector

Input signal, specified as a column vector.

Data Types: single | double
Complex Number Support: Yes

Output Arguments

expand all

`y` — Compensated output signal
complex column vector

Compensated output signal, returned as a complex column vector with the same dimensions and data type as the input x.

`estimate` — Estimate of frequency offset
scalar

Estimate of the frequency offset, returned as a scalar.

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

Specific to `comm.CoarseFrequencyCompensator`

`info`	Characteristic information about coarse frequency compensator
`clone`	Create duplicate System object
`isLocked`	Determine if System object is in use

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

collapse all

Compensate for Frequency Offset in QPSK Signal

Open Live Script

Compensate for a 4 kHz frequency offset imposed on a noisy QPSK signal.

Set up the example parameters.

nSym = 2048;       % Number of input symbols
sps = 4;           % Samples per symbol
nSamp = nSym*sps;  % Number of samples
fs = 80000;        % Sampling frequency (Hz)

Create a square root raised cosine transmit filter.

txfilter = comm.RaisedCosineTransmitFilter( ...
    RolloffFactor=0.2, ...
    FilterSpanInSymbols=8, ...
    OutputSamplesPerSymbol=sps);

Create a phase frequency offset object to introduce the 4 kHz frequency offset.

freqOffset = comm.PhaseFrequencyOffset( ...
    FrequencyOffset=-4000, ...
    SampleRate=fs);

Create a coarse frequency compensator object to compensate for the offset.

freqComp = comm.CoarseFrequencyCompensator( ...
    Modulation="qpsk", ...
    SampleRate=fs, ...
    FrequencyResolution=1);

Generate QPSK symbols, filter the modulated data, pass the signal through an AWGN channel, and apply the frequency offset.

data = randi([0 3],nSym,1);
modData = pskmod(data,4,pi/4);
txSig = txfilter(modData);
rxSig = awgn(txSig,20,"measured");
offsetData = freqOffset(rxSig);

Compensate for the frequency offset using the coarse frequency compensator. For high frequency offsets, applying coarse frequency compensation prior to receive filtering is beneficial because filtering suppresses energy in the useful spectrum.

[compensatedData,estFreqOffset] = freqComp(offsetData);

Display the estimate of the frequency offset.

estFreqOffset

estFreqOffset = 
-3.9999e+03

Return information about the coarse frequency compensator System object. To obtain the FFT length, you must call the coarse frequency compensator System object prior to calling the info object function.

freqCompInfo = info(freqComp)

freqCompInfo = struct with fields:
    FFTLength: 131072
    Algorithm: 'FFT-based'

Create a spectrum analyzer object and plot the offset and compensated spectra. Verify that the compensated signal has a center frequency at 0 Hz and that the offset signal has a center frequency at -4 kHz.

sa = spectrumAnalyzer( ...
    SampleRate=fs, ...
    ShowLegend=true, ...
    ChannelNames=["Offset Signal","Compensated Signal"]);
sa([offsetData compensatedData])

Compensate for Frequency Offset Using Coarse and Fine Compensation

Open Live Script

Correct for a phase and frequency offset in a noisy QAM signal by using a carrier synchronizer. Then correct for the offsets using both a carrier synchronizer and a coarse frequency compensator.

Set the example parameters.

fs = 10000;   % Symbol rate (Hz)
sps = 4;      % Samples per symbol
M = 16;       % Modulation order
k = log2(M);  % Bits per symbol
EbNo = 20;    % Eb/No (dB)
SNR = convertSNR(EbNo,"ebno",BitsPerSymbol=k,SamplesPerSymbol=sps);

Create a constellation diagram object to visualize the effects of the offset compensation techniques. Specify the constellation diagram to display only the last 4000 samples.

constdiagram = comm.ConstellationDiagram( ...
    ReferenceConstellation=qammod(0:M-1,M), ...
    SamplesPerSymbol=sps, ...
    SymbolsToDisplaySource='Property', ...
    SymbolsToDisplay=4000, ...
    XLimits=[-5 5], ...
    YLimits=[-5 5]);

Introduce a frequency offset of 400 Hz and a phase offset of 30 degrees.

phaseFreqOffset = comm.PhaseFrequencyOffset( ...
    FrequencyOffset=400, ...
    PhaseOffset=30, ...
    SampleRate=fs);

Generate random data symbols and apply 16-QAM modulation.

data = randi([0 M-1],10000,1);
modSig = qammod(data,M);

Create a raised cosine filter object and filter the modulated signal.

txfilter = comm.RaisedCosineTransmitFilter( ...
    OutputSamplesPerSymbol=sps, ...
    Gain=sqrt(sps));
txSig = txfilter(modSig);

Apply the phase and frequency offset, and then pass the signal through the AWGN channel.

freqOffsetSig = phaseFreqOffset(txSig);
rxSig = awgn(freqOffsetSig,SNR);

Apply fine frequency correction to the signal by using the carrier synchronizer.

fineSync = comm.CarrierSynchronizer( ...
    DampingFactor=0.7, ...
    NormalizedLoopBandwidth=0.005, ...
    SamplesPerSymbol=sps, ...
    Modulation='QAM');
rxData = fineSync(rxSig);

Display the constellation diagram of the last 4000 symbols.

constdiagram(rxData)

Even with time to converge, the spiral nature of the plot shows that the carrier synchronizer has not yet compensated for the large frequency offset. The 400 Hz offset is 1% of the sample rate.

Repeat the process with a coarse frequency compensator inserted before the carrier synchronizer.

Create a coarse frequency compensator to reduce the frequency offset to a manageable level.

coarseSync = comm.CoarseFrequencyCompensator( ...
    Modulation='QAM', ...
    FrequencyResolution=1, ...
    SampleRate=fs*sps);

Pass the received signal to the coarse frequency compensator and then to the carrier synchronizer.

syncCoarse = coarseSync(rxSig);
rxData = fineSync(syncCoarse);

Plot the constellation diagram of the signal after coarse and fine frequency compensation. The received data now aligns with the reference constellation.

constdiagram(rxData)

Algorithms

expand all

Correlation-Based Estimation

Reference [ 1 ] describes the correlation-based estimation algorithm used to estimate the frequency offset for PSK and PAM signals. To determine the frequency offset, Δf, the algorithm performs a maximum likelihood (ML) estimation of the complex-valued oscillation exp(j2πΔft). The observed signal, r_k, is represented as

$r_{k} = e^{j (2 π Δ f k T_{s} + θ)}, 1 \leq k \leq N$

T_s is the sampling interval, θ is an unknown random phase, and N is the number of samples. The ML estimation of the frequency offset is equivalent to seeking the maximum of the likelihood function,

$Λ (Δ f) \approx {| \sum_{i = 1}^{N} r_{i} e^{- j 2 π Δ f i T_{s}} |}^{2} = \sum_{k = 1}^{N} \sum_{m = 1}^{N} r_{k} r_{m}^{*} e^{- j 2 π Δ f T_{s} (k - m)}$

After simplifying, the problem is expressed as a discrete Fourier transform, weighted by a parabolic windowing function. It is expressed as

$Im {\sum_{k = 1}^{N - 1} k (N - k) R (k) e^{j 2 π Δ \hat{f} T_{s}}} = 0$

R(k) denotes the estimated autocorrelation of the sequence r_k and is represented as

$R (k) ≜ \frac{1}{N - k} \sum_{i = k + 1}^{N} r_{i} r_{i - k}^{*}, 0 \leq k \leq N - 1$

The term k(N–k) is the parabolic windowing function. In [ 1 ], it is shown that R(k) is a poor estimate of the autocorrelation of r_k when k = 0 or when k is close to N. Consequently, the windowing function can be expressed as a rectangular sequence of 1s for k = 1, 2, ..., L, where L ≤ N – 1. The result is a modified ML estimation strategy in which

$Im {\sum_{k = 1}^{L} R (k) e^{- j 2 π Δ \hat{f} k T_{s}}} = 0$

This equation results in an estimate of $Δ \hat{f}$ in which

$Δ \hat{f} ≅ \frac{f_{s a m p}}{π (L + 1)} \arg {\sum_{k = 1}^{L} R (k)}$

The sampling frequency, f_samp, is the reciprocal of T_s. The number of elements used to compute the autocorrelation sequence, L, are determined as

$L = round (\frac{f_{s a m p}}{f_{m a x}}) - 1$

f_max is the maximum expected frequency offset and round is the nearest integer function. The frequency offset estimate improves when L ≥ 7 and leads to the recommendation that f_max ≤ f_samp / (4M).

FFT-Based Estimation

FFT-based estimation algorithms can be used to estimate the frequency offset for various modulation types. The coarse frequency compensator implementation supports these modulation methods by using the algorithm noted.

For BPSK, QPSK, 8PSK, PAM, or QAM modulation, the coarse frequency compensator uses the FFT-based algorithm described in [ 2 ]. The algorithm estimates $Δ \hat{f}$ by using a periodogram of the m^th power of the received signal and is given as

$Δ \hat{f} = \frac{f_{s a m p}}{N \cdot m} \arg \max_{f} | \sum_{k = 0}^{N - 1} r^{m} (k) e^{- j 2 π k t / N} |, (- \frac{R_{s y m}}{2} \leq f \leq \frac{R_{s y m}}{2})$
where m is the modulation order, r(k) is the received sequence, R_sym is the symbol rate, and N is the number of samples. The algorithm searches for a frequency that maximizes the time average of the mth power of the received signal multiplied by various frequencies in the range of [–R_sym / 2, R_sym / 2]. Because the form of the algorithm is the definition of the discrete Fourier transform of r^m(t), searching for a frequency that maximizes the time average is equivalent to searching for a peak line in the spectrum of r^m(t). The number of points required by the FFT is

$N = 2^{⌈ \log_{2} (\frac{f_{s a m p}}{f_{r}}) ⌉}$
where f_r is the desired frequency resolution.
For OQPSK modulation, the coarse frequency compensator uses the FFT-based algorithm described in [ 4 ]. The algorithm searches for spectral peaks at ±200 kHz around the symbol rate. This technique locates desired peaks in the presence of interference from spectral content around baseband frequencies due to filtering.

References

[1] Luise, M., and R. Reggiannini. “Carrier Frequency Recovery in All-Digital Modems for Burst-Mode Transmissions.” IEEE^® Transactions on Communications 43, no. 2/3/4 (Feb. 1995): 1169–78.

[2] Wang, Y., et al. “Non-Data-Aided Feedforward Carrier Frequency Offset Estimators for QAM Constellations: A Nonlinear Least-Squares Approach.” EURASIP Journal on Advances in Signal Processing 2004, no. 13 (Dec. 2004): 856139. https://doi.org/10.1155/S1110865704403175.

[3] Nakagawa, Tadao, et al. “Non-Data-Aided Wide-Range Frequency Offset Estimator for QAM Optical Coherent Receivers.” Optical Fiber Communication Conference/National Fiber Optic Engineers Conference 2011, OMJ1. OSA, 2011. https://doi.org/10.1364/OFC.2011.OMJ1.

[4] Olds, Jonathan. Designing an OQPSK demodulator.

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

Introduced in R2015b

expand all

R2023b: Default settings change

The comm.CoarseFrequencyCompensator System object has new default values as shown in the table.

Property	New Default	Previous Default
`FrequencyResolution`	`100`	`0.001`
`MaximumFrequencyOffset`	`5e3`	`0.05`
`SampleRate`	`1e6`	`1`

When executing code created in a previous release, confirm the coarse frequency compensator settings. The new default settings change your results. To produce results using the previous default settings, you can manually update the settings of your System object.

comm.CoarseFrequencyCompensator

Description

Creation

Syntax

Description

Properties

`Modulation` — Modulation type
`'QAM'` (default) | `'8PSK'` | `'BPSK'` | `'OQPSK'` | `'PAM'` | `'QPSK'`

`Algorithm` — Algorithm used to estimate frequency offset
`'FFT-based'` (default) | `'Correlation-based'`

Dependency

`FrequencyResolution` — Frequency resolution
`100` (default) | positive scalar

`MaximumFrequencyOffset` — Maximum measurable frequency offset
`5e3` (default) | positive scalar

Dependency

`SampleRate` — Sample rate
`1e6` (default) | positive scalar

`SamplesPerSymbol` — Samples per symbol
`4` (default) | even integer, greater than or equal to `4`

Dependency

Usage

Syntax

Description

Input Arguments

`x` — Input signal
column vector

Output Arguments

`y` — Compensated output signal
complex column vector

`estimate` — Estimate of frequency offset
scalar

Object Functions

Specific to `comm.CoarseFrequencyCompensator`

Common to All System Objects

Examples

Compensate for Frequency Offset in QPSK Signal

Compensate for Frequency Offset Using Coarse and Fine Compensation

Algorithms

Correlation-Based Estimation

FFT-Based Estimation

References

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Version History

R2023b: Default settings change

See Also

Objects

Blocks

comm.CoarseFrequencyCompensator

Description

Creation

Syntax

Description

Properties

Modulation — Modulation type 'QAM' (default) | '8PSK' | 'BPSK' | 'OQPSK' | 'PAM' | 'QPSK'

Algorithm — Algorithm used to estimate frequency offset 'FFT-based' (default) | 'Correlation-based'

Dependency

FrequencyResolution — Frequency resolution 100 (default) | positive scalar

MaximumFrequencyOffset — Maximum measurable frequency offset 5e3 (default) | positive scalar

Dependency

SampleRate — Sample rate 1e6 (default) | positive scalar

SamplesPerSymbol — Samples per symbol 4 (default) | even integer, greater than or equal to 4

Dependency

Usage

Syntax

Description

Input Arguments

x — Input signal column vector

Output Arguments

y — Compensated output signal complex column vector

estimate — Estimate of frequency offset scalar

Object Functions

Specific to comm.CoarseFrequencyCompensator

Common to All System Objects

Examples

Compensate for Frequency Offset in QPSK Signal

Compensate for Frequency Offset Using Coarse and Fine Compensation

Algorithms

Correlation-Based Estimation

FFT-Based Estimation

References

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Version History

R2023b: Default settings change

See Also

Objects

Blocks

`Modulation` — Modulation type
`'QAM'` (default) | `'8PSK'` | `'BPSK'` | `'OQPSK'` | `'PAM'` | `'QPSK'`

`Algorithm` — Algorithm used to estimate frequency offset
`'FFT-based'` (default) | `'Correlation-based'`

`FrequencyResolution` — Frequency resolution
`100` (default) | positive scalar

`MaximumFrequencyOffset` — Maximum measurable frequency offset
`5e3` (default) | positive scalar

`SampleRate` — Sample rate
`1e6` (default) | positive scalar

`SamplesPerSymbol` — Samples per symbol
`4` (default) | even integer, greater than or equal to `4`

`x` — Input signal
column vector

`y` — Compensated output signal
complex column vector

`estimate` — Estimate of frequency offset
scalar

Specific to `comm.CoarseFrequencyCompensator`

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.