# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# comm.PhaseNoise System object

Package: comm

Apply phase noise to complex, baseband signal

## Description

The `PhaseNoise` object applies phase noise to a complex, baseband signal. This phase noise has a 1/f spectral characteristic over its entire frequency range.

To apply phase noise to a complex, baseband signal:

1. Define and set up your phase noise object. See Construction.

2. Call `step` to apply phase noise to a complex, baseband signal according to the properties of `comm.PhaseNoise`. The behavior of `step` is specific to each object in the toolbox.

 Note:   Starting in R2016b, instead of using the `step` method to perform the operation defined by the System object™, you can call the object with arguments, as if it were a function. For example, ```y = step(obj,x)``` and `y = obj(x)` perform equivalent operations.

## Construction

`H = comm.PhaseNoise` creates a phase noise System object, `H`. This object applies phase noise with the specified level at the specified frequency offset to a complex, baseband input signal.

`H = comm.PhaseNoise(Name,Value)` creates a phase noise 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.PhaseNoise(LEVEL,OFFSET,Name,Value)` creates a phase noise object, `H`. This object has the `Level` property set to `LEVEL`, the `FrequencyOffset` property set to `OFFSET` and the other specified properties set to the specified values.

## Properties

 `Level` Phase noise level Specify the phase noise level in decibels relative to carrier per Hertz (dBc/Hz) at a frequency offset specified by the `FrequencyOffset` property. The default is `[-60 -80]`. This property requires a negative, real scalar or vector of data type `double`. `FrequencyOffset` Frequency offset Specify the frequency offset in Hertz as a nonnegative, real scalar or increasing vector of data type `double`. The default is `[20 200]`. `SampleRate` Sample rate Specify the sample rate in Hertz as a positive, real scalar or vector of data type double. The default is `1024`. The System object does not use this property when you specify `Level` and `FrequencyOffset` as scalars.

## Methods

 clone Create phase noise 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 step Apply phase noise to a complex, baseband signal

## Examples

expand all

Add a phase noise vector and frequency offset vector to a 16-QAM signal. Then, plot the signal.

Create 16-QAM modulator having an average constellation power of 10 W.

```modulator = comm.RectangularQAMModulator(16, ... 'NormalizationMethod','Average power', 'AveragePower',10); ```

Create a phase noise object.

```pnoise = comm.PhaseNoise('Level',-50,'FrequencyOffset',20); ```

Generate modulated symbols.

```data = randi([0 15],1000,1); modData = modulator(data); ```

Apply phase noise and plot the result.

```y = pnoise(modData); scatterplot(y) ```

Create a sine wave generator having a carrier frequency of 100 Hz, a sample rate of 1000 Hz, and a frame size of 10,000 samples.

```sinewave = dsp.SineWave('Frequency',100,'SampleRate',1000, ... 'SamplesPerFrame',1e4,'ComplexOutput',true); ```

Create a phase noise object. Specify the phase noise level to be -40 dBc/Hz for a 100 Hz offset and -70 dBc/Hz for a 200 Hz offset.

```pnoise = comm.PhaseNoise('Level',[-40 -70],'FrequencyOffset',[100 200], ... 'SampleRate',1000); ```

Create a spectrum analyzer.

```spectrum = dsp.SpectrumAnalyzer('SampleRate',1000,'SpectralAverages',10,'PowerUnits','dBW'); ```

Generate a sine wave. Add phase noise to the sine wave. Plot the spectrum of the noisy signal.

```x = sinewave(); y = pnoise(x); spectrum(y) ```

The phase noise is -40 dBW within ±100 Hz of the carrier. The phase noise is -70 dB below the carrier for offsets greater than 200 Hz.

## Algorithms

The output of the phase noise object, yk, is related to input sequence xk by ${y}_{k}={x}_{k}{e}^{j{\varphi }_{k}}$, where ϕk is the phase noise. The phase noise is filtered Gaussian noise such that ${\varphi }_{k}=f\left({n}_{k}\right)$, where nk is the noise sequence and f represents a filtering operation.

If `FrequencyOffset` is a scalar, an IIR digital filter is used in which the numerator coefficient, λ, is

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

where foffset 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 and i = {1, 2,..., 64}.

If `FrequencyOffset` is a vector, an FIR filter is used. The phase noise level is determined through log10 interpolation for frequency offsets over the range [df, fs/2], where df is the frequency resolution and fs is the sample rate. The frequency resolution is equal to $\frac{{f}_{s}}{2}\left(\frac{1}{{N}_{t}}\right)$, where Nt is the number of taps. The object increases Nt until either the frequency resolution is less than the minimum value of the `FrequencyOffset` vector or a maximum value of 512 is reached. This value was selected to balance the conflicting requirements of a small frequency resolution and fast filter performance.

The object properties correspond to the block parameters, except:

• The object respects the data types and does perform any casting other than casting the output to the input data type. The output of the object is cast to the input data type first, before multiplying with the input signal. This order prevents the output (phase distorted) signal from being downcast to single precision if any of the properties are of data type single while the input data type is double precision.

• This object uses the MATLAB® default random stream to generate random numbers. The block uses a random number generator based on the V5 RANDN (Ziggurat) algorithm. In addition, the block uses an initial seed, set with the Initial seed parameter to initialize the random number generator. Every time the system that contains the block runs, the block generates the same sequence of random numbers. To generate reproducible numbers using this object, reset the MATLAB default random stream using the following code.

`reset(RandStream.getGlobalStream)`
For more information, see help for `RandStream`.