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.

The `phased.ReceiverPreamp`

object lets you model
the effects of gain and component-based noise on the signal-to-noise
ratio (SNR) of received signals. `phased.ReceiverPreamp`

operates
on baseband signals. The object is not intended to model system effects
at RF or intermediate frequency (IF) stages.

The `phased.ReceiverPreamp`

object has the following
modifiable properties:

`EnableInputPort`

— A logical property that enables you to specify when the receiver is on or off. Input the actual status of the receiver as a vector to`step`

. This property is useful when modeling a monostatic radar system. In a monostatic radar, it is important to ensure the transmitter and receiver are not operating simultaneously. See`phased.Transmitter`

and Transmitter.`Gain`

— Gain in dB (*G*)_{dB}`LossFactor`

— Loss factor in dB (*L*)_{dB}`NoiseMethod`

— Specify noise input as noise power or noise temperature`NoiseFigure`

— Receiver noise figure in dB (*F*)_{dB}`ReferenceTemperature`

— Receiver reference temperature in kelvin (*T*)`SampleRate`

— Sample rate (*f*_{s})`NoisePower`

— Noise power specified in Watts (σ^{2})`NoiseComplexity`

— Specify noise as real-valued or complex-valued`EnableInputPort`

— Add input to specify when the receiver is active`PhaseNoiseInputPort`

— Add input to specify phase noise for coherent on receive receiver`SeedSource`

— Lets you specify random number generator seed`Seed`

— Random number generator seed

The output signal, *y[n]*, of the `phased.ReceiverPreamp`

System
object™ equals
the input signal scaled by the ratio of receiver amplitude gain to
amplitude loss plus additive noise

$$y[n]=\frac{G}{L}x[n]+\frac{\sigma}{\sqrt{2}}w[n]$$

where *x[n]* is
the complex-valued input signal and *w[n]* is unit-variance
noise complex-valued noise.

When the input signal is real-valued, the output signal, *y[n]*,
equals the real-valued input signal scaled by the ratio of receiver
amplitude gain to amplitude loss plus real-valued additive noise

$$y[n]=\frac{G}{L}x[n]+\sigma w[n]$$

.

The amplitude gain, *G*, and loss, *L*,
can be express in terms of the input dB parameters by

$$\begin{array}{l}G={10}^{{G}_{dB}/20}\\ L={10}^{{L}_{dB}/20}\end{array}$$

.

respectively.

The additive noise for the receiver is modeled as a zero-mean
complex white Gaussian noise vector with variance, *σ ^{2}*,
equal to the noise power. The real and imaginary parts of the noise
vector each have variance equal to 1/2 the noise power.

You can set the noise power directly by choosing the `NoiseMethod`

property
to be `'Noise power'`

and then setting the `NoisePower`

property
to a real positive number. Alternatively, you can set the noise power
using the system temperature by choosing the `NoiseMethod`

property
to be `'Noise temperature'`

. Then

$${\sigma}^{2}={k}_{B}BTF$$

where *k _{B}* is
Boltzmann’s constant,

The noise figure, *F*,
is a dimensionless quantity that indicates how much a receiver deviates
from an ideal receiver in terms of internal noise. An ideal receiver
produces thermal noise power defined by noise bandwidth and temperature.
In terms of power units, the noise figure *F = 10 ^{FdB/10}*.
A noise figure of 0 dB indicates that the noise power of a receiver
equals the noise power of an ideal receiver. Because an actual receiver
cannot exhibit a noise power value less than an ideal receiver, the
noise figure is always greater than or equal to one. In decibels,
the noise figure must be greater than or equal to zero.

To model the
effect of the receiver preamp on the signal, `phased.ReceiverPreamp`

computes
the *effective system noise temperature* by taking
the product of the reference temperature, *T*, and
the noise figure *F* in power units. See `systemp`

for details.

Specify a `phased.ReceiverPreamp`

System object™ with a gain of 20 dB, a noise figure of 5 dB, and a reference temperature of 290 degrees kelvin.

**Note:** This example runs only in R2016b or later. If you are using an earlier release, replace each call to the function with the equivalent `step`

syntax. For example, replace `myObject(x)`

with `step(myObject,x)`

.

receiver = phased.ReceiverPreamp('Gain',20,... 'NoiseFigure',5,'ReferenceTemperature',290,... 'SampleRate',1e6,'SeedSource','Property','Seed',1e3);

Assume a 100-Hz sine wave input with an amplitude of 1 microvolt. Because the Phased Array System Toolbox assumes that all modeling is done at baseband, use a complex exponential as the input when executing the System object.

```
t = unigrid(0,0.001,0.1,'[)');
x = 1e-6*exp(1i*2*pi*100*t).';
y = receiver(x);
```

The output of the `phased.ReceiverPreamp.step`

method is complex-valued as expected.

Now show how the same output can be produced from the multiplicative amplitude gain and additive noise. First assume that the noise bandwidth equals the sample rate of the receiver preamp (1 MHz). Then, the noise power is equal to:

NoiseBandwidth = receiver.SampleRate; noisepow = physconst('Boltzmann')*... systemp(receiver.NoiseFigure,receiver.ReferenceTemperature)*NoiseBandwidth;

The noise power is the variance of the additive white noise. To determine the correct amplitude scaling of the input signal, note that the gain is 20 dB. Because the loss factor in this case is 0 dB, the scaling factor for the input signal is found by solving the following equation for the multiplicative gain *G* from the gain in dB, $${G}_{dB}$$:

$$G=1{0}^{({G}_{dB}/20)}$$

G = 10^(receiver.Gain/20)

G = 10

The gain is 10. By scaling the input signal by a factor of ten and adding complex white Gaussian noise with the appropriate variance, you produce an output equivalent to the preceding call to `phased.ReceiverPreamp.step`

(use the same seed for the random number generation).

rng(1e3); y1 = G*x + sqrt(noisepow/2)*(randn(size(x))+1j*randn(size(x)));

Compare a few values of `y`

to `y1`

.

disp(y1(1:10) - y(1:10))

0 0 0 0 0 0 0 0 0 0