# step

**System object: **phased.ScatteringMIMOChannel

**Package: **phased

Propagate signals in scattering MIMO channel

## Syntax

## Description

**Note**

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.

uses the scattering MIMO channel, `Y`

= step(`channel`

,`X`

)`channel`

, to propagate a
signal, `X`

, from a transmitting array towards multiple
scatterers, and returns the scattered signals, `Y`

, to a
receiving array.

To enable this syntax, set the `TransmitArrayMotionSource`

, `ReceiveArrayMotionSource`

,
and `ScattererSpecificationSource`

properties to `'Property'`

.

`[___] = step(___,`

specifies the scatterer positions and velocities, and the scattering
coefficients.`scatpos`

,`scatvel`

,`scatcoef`

)

To enable this syntax, set the `TransmitArrayMotionSource`

and
`ReceiveArrayMotionSource`

properties to
`'Property'`

, set
`ScattererSpecificationSource`

to ```
'Input
port'
```

, and set the `Polarization`

property to
`'None'`

.

`[___] = step(___,`

specifies the scatterer positions, `scatpos`

,`scatvel`

,`scatmat`

,`scataxes`

)`scatpos`

, and velocities,
`scatvel`

, the scattering matrix,
`scatmat`

, and the scatterer orientation axes,
`scataxes`

.

To enable this syntax, set the `TransmitArrayMotionSource`

and
`ReceiveArrayMotionSource`

properties to
`'Property'`

, set
`ScattererSpecificationSource`

to ```
'Input
port'
```

, and set the `Polarization`

property to
`'Combined'`

or `'Dual'`

.

`[___,`

also returns the channel response matrices, `CR_HH`

,`CR_HV`

,`CR_VH`

,`CR_V`

,`TAU`

]
= step(`channel`

,___)`CR_HH`

,
`CR_HV`

, `CR_VH`

, and
`CR_V`

, using any of the previous input argument
combinations.

To enable this syntax, set the `ChannelResponseOutputPort`

property to `true`

and set the `Polarization`

property to `'Dual'`

.

**Note**

The object performs an initialization the first time the `step`

method
is executed. This initialization locks nontunable properties and input
specifications, such as dimensions, complexity, and data type of the
input data. If you change a nontunable property or an input specification,
the System object issues an error. To change nontunable properties
or inputs, you must first call the `release`

method
to unlock the object.

## Input Arguments

`channel`

— Scattering MIMO channel

`phased.ScatteringMIMOChannel`

System object

Scattering MIMO channel, specified as a `phased.ScatteringMIMOChannel`

System object.

**Example: **`phased.ScatteringMIMOChannel`

`X`

— Transmitted narrowband signal

*M*-by-*N*_{t}
complex-valued matrix

_{t}

Transmitted narrowband signal, specified as an
*M*-by-*N _{t}*
complex-valued matrix. The quantity

*M*is the number of samples in the signal, and

*N*is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

_{t}The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`XH`

— Transmitted narrowband H-polarization signal

*M*-by-*N*_{t}
complex-valued matrix

_{t}

Transmitted narrowband *H*-polarization signal, specified
as an *M*-by-*N _{t}*
complex-valued matrix. The quantity

*M*is the number of samples in the signal, and

*N*is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

_{t}The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`XV`

— Transmitted narrowband V-polarization signal

*M*-by-*N*_{t}
complex-valued matrix

_{t}

Transmitted narrowband *V*-polarization signal, specified
as an *M*-by-*N _{t}*
complex-valued matrix. The quantity

*M*is the number of samples in the signal, and

*N*is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

_{t}The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`txpos`

— Position of transmitting antenna array

real-valued three-element column vector

Position of transmitting antenna array, specified as real-valued three-element column vector
taking the form `[x;y;z]`

. The vector elements correspond
to the *x*, *y*, and *z*
positions of the array. Units are in meters.

**Example: **`[1000;100;500]`

#### Dependencies

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`txvel`

— Velocity of transmitting antenna array

real-valued three-element column vector

Velocity of transmitting antenna array, specified as a real-valued
three-element column vector taking the form `[vx;vy;vz]`

.
The vector elements correspond to the *x*, *y*,
and *z* velocities of the array. Units are in meters
per second.

**Example: **`[10;0;5]`

#### Dependencies

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`txaxes`

— Axes orientation of transmitting antenna array

real-valued 3-by-3 real orthonormal matrix

Axes orientation of transmitting antenna array, specified as a real-valued 3-by-3 real
orthonormal matrix. The matrix defines the orientation of the array local
coordinate system with respect to the global coordinates. Matrix columns
correspond to the directions of the *x*,
*y*, and *z* axes of the local
coordinate system. Units are dimensionless.

**Example: **`rotx(35)`

#### Dependencies

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxpos`

— Position of receiving antenna array

real-valued three-element column vector

Position of receiving antenna array, specified as a real-valued
three-element column vector taking the form `[x;y;z]`

.
The vector elements correspond to the *x*, *y*,
and *z* positions of the array. Units are in meters.

**Example: **`[1000;100;500]`

#### Dependencies

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxvel`

— Velocity of receiving antenna array

real-valued three-element column vector

Velocity of receiving antenna array, specified as a real-valued three-element column vector
taking the form `[vx;vy;vz]`

. The vector elements
correspond to the *x*, *y*, and
*z* velocities of the array. Units are in meters per
second.

**Example: **`[10;0;5]`

#### Dependencies

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxaxes`

— Axes orientation of receiving antenna array

real-valued 3-by-3 real orthonormal matrix

Axes orientation of receiving antenna array, specified as a real-valued 3-by-3 real
orthonormal matrix. The matrix defines the orientation of the array local
coordinate system with respect to the global coordinates. Matrix columns
correspond to the directions of the *x*,
*y*, and *z* axes of the local
coordinate system. Units are dimensionless.

**Example: **`rotx(35)`

#### Dependencies

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatpos`

— Positions of scatterers

real-valued 3-by-*N*_{s}
matrix

_{s}

Positions of scatterers, specified as a real-valued
3-by-*N _{s}* matrix. The matrix
contains the

*(x,y,z)*positions of scatterers. Each column of the matrix specifies a different scatterer and takes the form

`[x;y;z]`

. Units are in meters.**Example: **`[1000;100;500]`

#### Dependencies

To enable this argument, set the `ScattererSpecificationSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatvel`

— Velocities of scatterers

real-valued 3-by-*N*_{s}
matrix

_{s}

Velocities of scatterers, specified as a real-valued
3-by-*N _{s}* matrix. The matrix
contains the

*(v*positions of scatterers. Each column of the matrix specifies a different scatterer and takes the form

_{x},v_{y},v_{z})`[vx;vy;vz]`

Units are in
meters per second.**Example: **`[1000;100;500]`

#### Dependencies

To enable this argument, set the `ScattererSpecificationSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatcoef`

— Scattering coefficients

complex-valued 1-by-*N*_{s}row
vector

_{s}

Scattering coefficients, specified as a complex-valued
1-by-*N _{s}*row vector. Each vector
element specifies the scattering coefficient of the corresponding scatterer.
Units are dimensionless.

**Example: **`[5+3*1i;4+1i;2]`

#### Dependencies

To enable this argument, set the `ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'None'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`scatmat`

— Scattering matrices

`[1 0;0 1]`

| complex–valued 2-by-2-by-*N*_{s}
array

Scattering matrices of the scatterers, specified as a complex–valued
2-by-2-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array represents the scattering matrix of a
scatterer. Each scattering matrix has the form ```
[s_hh s_hv;s_vh
s_vv]
```

. For example, the component `s_hv`

specifies the complex scattering response when the input signal is
vertically polarized and the reflected signal is horizontally polarized. The
other components are defined similarly. Units are in square meters.

#### Dependencies

To enable this property, set the
`ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`scataxes`

— Scatterer orientation axes

real-valued 3-by-3-by-*N*_{s}
array

Scatterer orientation axes, specified as a real-valued
3-by-3-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array represents the orientation axes matrix
of a scatterer. The columns of the matrix represent the
*x*- ,*y*-, and *z*-axes
of the scatterer. Units are dimensionless.

#### Dependencies

To enable this property, set the
`ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

## Output Arguments

`Y`

— Received narrowband signal

complex-valued
*M*-by-*N*_{r}
matrix

_{r}

Received narrowband signal, returned as an
*M*-by-N_{r} complex-valued matrix.
*M* is the number of samples in the signal, and
*N _{r}* is the number of
receiving array elements. Each column represents the signal received by the
corresponding array element.

**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`YH`

— Received narrowband H-polarization signal

complex-valued
*M*-by-*N*_{r}
matrix

_{r}

Received narrowband *H*-polarization signal, returned as
a complex-valued
*M*-by-*N _{r}*
matrix.

*M*is the number of samples in the signal, and

*N*is the number of receiving array elements. Each column represents the signal received by the corresponding array element.

_{r}**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`YV`

— Received narrowband V-polarization signal

complex-valued
*M*-by-*N*_{r}
matrix

_{r}

Received narrowband *V*-polarization signal, returned as
a complex-valued
*M*-by-*N _{r}*
matrix.

*M*is the number of samples in the signal, and

*N*is the number of receiving array elements. Each column represents the signal received by the corresponding array element.

_{r}**Example: **`[1,1;j,1;0.5,0]`

#### Dependencies

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR`

— Channel response

complex-valued
*N*_{t}-by-*N*_{r}-by-*N*_{c}
array

_{t}

_{r}

_{c}

Channel response, returned as an
*N _{t}*-by-

*N*-by-

_{r}*N*complex-valued array.

_{c}*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

#### Dependencies

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_HH`

— Channel response for H-input to H-output

complex-valued
*N*_{t}-by-*N*_{r}-by-*N*_{c}
array

_{t}

_{r}

_{c}

Channel response from H-polarization input to H-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*-by-

_{r}*N*array.

_{c}*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

#### Dependencies

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_HV`

— Channel response for H-input to V-output

complex-valued
*N*_{t}-by-*N*_{r}-by-*N*_{c}
array

_{t}

_{r}

_{c}

Channel response from H-polarization input to V-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*-by-

_{r}*N*array.

_{c}*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

#### Dependencies

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_VH`

— Channel response for V-input to H-output

complex-valued
*N*_{t}-by-*N*_{r}-by-*N*_{c}
array

_{t}

_{r}

_{c}

Channel response from V-polarization input to H-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*-by-

_{r}*N*array.

_{c}*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

#### Dependencies

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_VV`

— Channel response for V-input to V-output

complex-valued
*N*_{t}-by-*N*_{r}-by-*N*_{c}
array

_{t}

_{r}

_{c}

Channel response from V-polarization input to V-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*-by-

_{r}*N*array.

_{c}*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

#### Dependencies

`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`TAU`

— Path delays

1-by-*N*_{s} real-valued
vector

_{s}

Path delays, returned as a
1-by-*N _{C}* real-valued vector.
Each element corresponds to the path time delay from the transmitting array
phase center to a scatterer and then to the receiving array phase center.

When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

#### Dependencies

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

.

**Data Types: **`double`

## Examples

### Propagate Signals in MIMO Channel

Create a 30 GHz MIMO channel with random scatterers. The scenario contains a stationary 21-element transmitting ULA array and a stationary 15-element receiving ULA array. The transmitting antennas have cosine responses and the receiving antennas are isotropic. Element spacing for both arrays is less than one-half wavelength. The channel has 50 randomly generated static scatterers within a specified bounding box. The transmit array is located at [0;20;50] meters and the receive array is located at [200;10;10] meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 30e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.CosineAntennaElement,... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement,... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray,... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayPosition',[0;20;50],... 'ReceiveArrayPosition',[200;10;10],'NumScatterers',50,... 'ScattererPositionBoundary',[10 180; -30 30; -30 30]);

Create a random data signal of ones and zeros for each transmitter.

x = randi(2,[100 21]) - 1;

Compute the received signals after propagating through the channel.

y = channel(x);

### Propagate Signals in MIMO Channel from Moving Transmitter

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array operating at 72 GHz, and a 15-element receiving ULA array. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the transmitting antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array starts at (0,20,50) meters and moves towards the receiver at 2 m/s. The receiving array is located at (200,10,10) meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txplatform = phased.Platform('MotionModel','Velocity','InitialPosition', ... [0;20;50],'Velocity',[2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayMotionSource','Input port', ... 'ReceiveArrayMotionSource','Property','ReceiveArrayPosition',[200;10;10],... 'ReceiveArrayOrientationAxes',rotz(180),... 'ScattererSpecificationSource','Property','ScattererPosition', ... [75 100 120; -10 20 12; 5 -5 8],'ScattererCoefficient',[1i,2+3i,-1+1i]);

Move the platforms for two time steps at one second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. The orientations are fixed.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [txpos,txvel] = txplatform(1); txaxes = eye(3); y = channel(x,txpos,txvel,txaxes); end

### Propagate Signals Through MIMO Channel to Moving Receiver

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array and a 15-element receiving ULA array. Both arrays operate at 72 GHz. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the receiving antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array is located at (0,20,50) meters. The receiving array starts at (200,10,10) meters and moves toward the transmitter at 2 m/s. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; rxplatform = phased.Platform('MotionModel','Velocity','InitialPosition',... [200;10;10],'Velocity',[-2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc, ... 'SampleRate',fs,'TransmitArrayMotionSource','Property',... 'TransmitArrayPosition',[0;20;50],'TransmitArrayOrientationAxes',eye(3,3), ... 'ReceiveArrayMotionSource','Input port','ScattererSpecificationSource', ... 'Property','ScattererPosition',[75 100 120; -10 20 12; 5 -5 8], ... 'ScattererCoefficient',[1i,2+3i,-1+1i],'SpecifyAtmosphere',false);

Move the platforms for two time steps at one-second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. Fix the array orientations.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [rxpos,rxvel] = rxplatform(1); rxaxes = rotz(45); y = channel(x,rxpos,rxvel,rxaxes); end

### Compute Propagated Signals Through MIMO Channel with Moving Scatterers

Create a MIMO channel containing 3 moving scatterers. The scenario contains a 21-element transmitting ULA array and a 15-element receiving ULA array. Both arrays operate at 72 GHz. The transmitting elements have cosine responses and the receiving antennas are isotropic. Element spacing for both arrays is less than one-half wavelength. The transmitting array is located at (0,20,50) meters. The receiving array is located at (200,10,10) meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz. Obtain the channel response matrix and time delays.

fc = 30e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc, ... 'SampleRate',fs,'TransmitArrayPosition',[0;20;50], ... 'ReceiveArrayPosition',[200;10;10],'ScattererSpecificationSource','Input port', ... 'ChannelResponseOutputPort',true);

Create a random data signal of ones and zeros for each transmitter.

x = randi(2,[100 21]) - 1;

Compute the received signals after propagating through the channel. Also return the channel matrix and delays.

scatpos = [75 100 120; -10 20 12; 5 -5 8]; scatvel = [0 0.5 0; -0.1 1.2 0.04; .05 -0.45 0.8]; scatcoef = [1i,2+3i,-1+1i]; [y,chmat,delays] = channel(x,scatpos,scatvel,scatcoef);

Display the dimensions of the channel matrix.

size(chmat)

`ans = `*1×3*
21 15 3

Display the time delays in microseconds.

delays*1e6

`ans = `*1×3*
0.7310 0.7196 0.6919

### Propagate Polarized Signals in MIMO Channel

Create a MIMO channel at 30 GHz with a 16-element transmit array and a 64-element receive array. Assume the elements are short-dipole antennas and the arrays are uniform linear arrays. The transmit array is located at [0;0;50] meters.

The receive array has an initial position at [200;0;0] meters and is moving at a speed of [10;0;0] meters/second. There are 200 static scatterers randomly located on the *xy* plane within a square centered at [200;0;0] and with a side length of 100 meters.

Use the channel to compute the propagated polarized signal. Assume the sample rate for the signal is 10 MHz and the frame length is 1000 samples. Collect 5 frames of received signal.

fc = 30e9; c = 3e8; lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',16,'ElementSpacing',lambda/2); rxarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',64,'ElementSpacing',lambda/2); Ns = 200; scatpos = [100*rand(1,Ns) + 150; 100*rand(1,Ns) + 150; zeros(1,Ns)]; temp = randn(1,Ns) + 1i*randn(1,Ns); scatcoef = repmat(eye(2),1,1,Ns).*permute(temp,[1 3 2]); scatax = repmat(eye(3),1,1,Ns); Nframesamp = 1000; Tframe = Nframesamp/fs; rxmobile = phased.Platform('InitialPosition',[200;0;0],... 'Velocity',[10;0;0],'OrientationAxesOutputPort',true); chan = phased.ScatteringMIMOChannel(... 'TransmitArray',txarray,... 'ReceiveArray',rxarray,... 'PropagationSpeed',c,... 'CarrierFrequency',fc,... 'SampleRate',fs,... 'Polarization','Dual',... 'TransmitArrayPosition',[0;0;50],... 'ReceiveArrayMotionSource','Input port',... 'ScattererSpecificationSource','Property',... 'ScattererPosition',scatpos,... 'ScatteringMatrix',scatcoef,... 'ScattererOrientationAxes',scatax); xh = randi(2,[Nframesamp 16])-1; xv = randi(2,[Nframesamp 16])-1; for m = 1:5 [rxpos,rxvel,rxax] = rxmobile(Tframe); [yh,yv] = chan(xh,xv,rxpos,rxvel,rxax); end

## Version History

**Introduced in R2017a**

## Open Example

You have a modified version of this example. Do you want to open this example with your edits?

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

# Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

## How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)