Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

Apply phase noise to baseband signal

The `comm.PhaseNoise`

System
object™ adds phase noise to a complex signal. This object emulates impairments
introduced by the local oscillator of a wireless communication transmitter or receiver. The
object generates filtered phase noise according to the specified spectral mask and adds it to
the input signal. For a description of the phase noise modeling, see Algorithms.

To add phase noise using a `comm.PhaseNoise`

object:

Create the

`comm.PhaseNoise`

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? (MATLAB).

`phznoise = comm.PhaseNoise`

`phznoise = comm.PhaseNoise(Name,Value)`

`phznoise = comm.PhaseNoise(level,offset,samplerate)`

creates a phase
noise System
object with default property values.`phznoise`

= comm.PhaseNoise

creates a phase noise object with the specified property `phznoise`

= comm.PhaseNoise(`Name`

,`Value`

)`Name`

set to
the specified `Value`

. You can specify additional name-value pair
arguments in any order as
(`Name1`

,`Value1`

,...,`NameN`

,`ValueN`

).

creates a phase noise object with the phase noise level, frequency offset, and sample rate
properties specified as value-only arguments. When specifying a value-only argument, you
must specify all preceding value-only arguments.`phznoise`

= comm.PhaseNoise(`level`

,`offset`

,`samplerate`

)

**For versions earlier than R2016b, use the step
function to run the System object algorithm. The arguments to
step are the object you created, followed by
the arguments shown in this section.**

**For example, y = step(obj,x) and y = obj(x) perform equivalent operations.**

`out = phznoise(in)`

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)

The output signal, *y*_{k}, is related to input
sequence *x*_{k} by *y*_{k}=*x*_{k}*e*^{jφk}, where *φ*_{k} is the phase noise.
The phase noise is filtered Gaussian noise such that *φ*_{k}=*f*(*n*_{k}), where *n*_{k} is the noise sequence
and *f* represents a filtering operation.

To model the phase noise, define the power spectrum density (PSD) mask characteristic by specifying scalar or vector values for the frequency offset and phase noise level.

For a scalar frequency offset and phase noise level specification, an IIR digital filter computes the spectrum mask. The spectrum mask has a 1/

*f*characteristic that passes through the specified point.For a vector frequency offset and phase noise level specification, an FIR filter computes the spectrum mask. The spectrum mask is interpolated across log10(

*f*). It is flat from DC to the lowest frequency offset, and from the highest frequency offset to half the sample rate.

**IIR Digital Filter**

For the IIR digital filter, the numerator coefficient is

$$\lambda =\sqrt{2\pi {f}_{offset}{10}^{L/10}}\text{\hspace{0.17em}},$$

where *f*_{offset} is the frequency offset in Hz and
*L* is the phase noise level in dBc/Hz. The denominator coefficients,
*γ*_{i}, are recursively determined as

$${\gamma}_{i}=\left(i-2.5\right)\frac{{\gamma}_{i-1}}{i-1}\text{\hspace{0.17em}},$$

where *γ*_{1} = 1, *i* = {1, 2,...,
*N*_{t}}, and *N*_{t} is the number of filter
coefficients. *N*_{t} is a power of 2, from
`2`

^{7 }to
`2`

^{19}. The value of
*N*_{t} grows as the phase noise offset decreases
towards 0 Hz.

**FIR Filter**

For the FIR filter, the phase noise level is determined through
log10(*f*) interpolation for frequency offsets over the range
[*df*, *f*_{s} / 2], where
*df* is the frequency resolution and
*f*_{s} is the sample rate. The phase noise is flat
from 0 Hz to the smallest frequency offset, and from the largest frequency offset to
*f*_{s} / 2. The frequency resolution is equal to $$\frac{{f}_{s}}{2}\left(\frac{1}{{N}_{t}}\right)$$, where *N*_{t} is the number of
coefficients, and is a power of 2 less than or equal to
`2`

^{16}. If
*N*_{t} <
`2`

^{8}, a time domain FIR filter is used.
Otherwise, a frequency domain FIR filter is used.

The algorithm increases *N*_{t} until these
conditions are met:

The frequency resolution is less than the minimum value of the frequency offset vector.

The frequency resolution is less than the minimum difference between two consecutive frequencies in the frequency offset vector.

The maximum number of FIR filter taps is

`2`

^{16}.

[1] Kasdin, N. J., "Discrete Simulation of Colored Noise and Stochastic Processes and
1/(f^alpha); Power Law Noise Generation." *The Proceedings of the IEEE*.
Vol. 83, No. 5, May, 1995, pp 802–827.