# step

System object: phased.ScatteringMIMOChannel
Namespace: phased

Propagate signals in scattering MIMO channel

## Syntax

``Y = step(channel,X)``
``[YH,YV] = step(channel,[XH,XV])``
``[___] = step(___,txpos,txvel,txaxes)``
``[___] = step(___,rxpos,rxvel,rxaxes)``
``[___] = step(___,scatpos,scatvel,scatcoef)``
``[___] = step(___,scatpos,scatvel,scatmat,scataxes)``
``````[___,CR,TAU] = step(channel,___)``````
``````[___,CR_HH,CR_HV,CR_VH,CR_V,TAU] = step(channel,___)``````
``[___] = step(___,steert)``
``[___] = step(___,wst)``
``[___] = step(___,steerr)``
``[___] = step(___,wsr)``
``````[Y,CR,TAU] = step(channel,X,txpos,txvel,txaxesrxpos,rxvel,rxaxes,scatpos,scatvel,scatcoef)``````
``````[Y,CR,TAU] = step(channel,X,steert,steerr,txpos,txvel,txaxesrxpos,rxvel,rxaxes,scatpos,scatvel,scatcoef)``````

## 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.

example

````Y = step(channel,X)` uses the scattering MIMO channel, `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'`. ```

example

````[YH,YV] = step(channel,[XH,XV])`propagates the polarized signals, `XH` and `XV`, through the H-port and V-port of the transmit array. The object returns the received signals, `YH` and `YV` to the H-port and V-port of the receive array.To enable this syntax, set the `Polarization` property to `'Dual'`.```

example

````[___] = step(___,txpos,txvel,txaxes)` also specifies the transmitting array position, velocity, and axes orientation.To enable this syntax, set the `ReceiveArrayMotionSource` and `ScattererSpecificationSource` properties to `'Property'` and set `TransmitArrayMotionSource` to ```'Input port'```.```

example

````[___] = step(___,rxpos,rxvel,rxaxes)` specifies the receiving array position, velocity, and axes orientation.To enable this syntax, set the `TransmitArrayMotionSource` and `ScattererSpecificationSource` properties to `'Property'` and set `ReceiveArrayMotionSource` to ```'Input port'```.```

example

````[___] = step(___,scatpos,scatvel,scatcoef)` specifies the scatterer positions and velocities, and the scattering coefficients.To enable this syntax, set the `TransmitArrayMotionSource` and `ReceiveArrayMotionSource` properties to `'Property'`, set `ScattererSpecificationSource` to ```'Input port'```, and set the `Polarization` property to `'None'`.```

example

````[___] = step(___,scatpos,scatvel,scatmat,scataxes)` specifies the scatterer positions, `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'`.```

example

``````[___,CR,TAU] = step(channel,___)``` also returns the channel response matrix, `CR`, and the channel path delays, `TAU`, using any of the previous input argument combinations.To enable this syntax, set the `ChannelResponseOutputPort` property to `true` and set the `Polarization` property to `'None'` or `'Combined'`.```
``````[___,CR_HH,CR_HV,CR_VH,CR_V,TAU] = step(channel,___)``` also returns the channel response matrices, `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'`.```
````[___] = step(___,steert)` uses `steert` as the subarray steering angle for the transmit array. This syntax is only applicable when you use subarrays in the `TransmitArray` property and set the `SubarraySteering` property in the `ReceiveArray` to either `'Phase'` or `'Time'`.```
````[___] = step(___,wst)` specifies the element weights, `wst` for each element within the transmit array subarrays. This syntax is applicable when you use a subarray as the transmit array and set the `SubarraySteering` property to `'Custom'` or an `phased.NRRectangularPanelArray` System object that uses each panel as a subarray.```
````[___] = step(___,steerr)` uses `steerr` as the subarray steering angle for the receive array. This syntax is only applicable when you use subarrays in the `ReceiveArray` property, set the `SubarraySteering` property in the `ReceiveArray` to either `'Phase'` or `'Time'`.```
````[___] = step(___,wsr)` specifies the element weights, `wsr`, for each element within the receive array subarrays. This syntax is applicable when you use a subarray as the receive array and set the `SubarraySteering` property to `'Custom'` or an `phased.NRRectangularPanelArray` System object that uses each panel as a subarray.```
```You can combine optional input arguments when their enabling properties are set. For example, ```[Y,CR,TAU] = step(channel,X,txpos,txvel,txaxesrxpos,rxvel,rxaxes,scatpos,scatvel,scatcoef)```.```[Y,CR,TAU] = step(channel,X,steert,steerr,txpos,txvel,txaxesrxpos,rxvel,rxaxes,scatpos,scatvel,scatcoef)``````

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

expand all

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

Example: `phased.ScatteringMIMOChannel`

Transmitted narrowband signal, specified as an M-by-Nt complex-valued matrix. The quantity M is the number of samples in the signal, and Nt is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

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

Transmitted narrowband H-polarization signal, specified as an M-by-Nt complex-valued matrix. The quantity M is the number of samples in the signal, and Nt is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

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

Transmitted narrowband V-polarization signal, specified as an M-by-Nt complex-valued matrix. The quantity M is the number of samples in the signal, and Nt is the number of transmitting array elements. Each column represents the signal transmitted by the corresponding array element.

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

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`

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`

Transmit subarray steering angle, specified as a scalar or a real-valued length-2 column vector. If `steert` is a vector, it takes the form of `[AzimuthAngle;ElevationAngle]`. If `steert` is a scalar, it represents the azimuth angle of the steering direction. The elevation angle is assumed to be zero. Units are in degrees.

#### Dependencies

This argument applies when you set the `SubarraySteering` property of subarrays specified by the `TransmitArray` property to either `'Phase'` or `'Time'`.

Data Types: `double`

Receive subarray steering angle, specified as a scalar or a real-valued length-2 column vector. If `steerr` is a vector, it takes the form of `[AzimuthAngle;ElevationAngle]`. If `steert` is a scalar, it represents the azimuth angle of the steering direction. The elevation angle is assumed to be zero. Units are in degrees.

#### Dependencies

This argument applies when you set the `SubarraySteering` property of subarrays specified by the `ReceiveArray` property to either `'Phase'` or `'Time'`.

Data Types: `double`

Transmit array element weights, specified as a matrix or a cell array.

#### Dependencies

This argument applies when you use a subarray to transmit and set the `SubarraySteering` property to `'Custom'` or use an NR rectangular panel array `phased.NRRectangularPanelArray` having each panel as a subarray.

Data Types: `double`
Complex Number Support: Yes

Receive array element weights, specified as a matrix or a cell array.

#### Dependencies

This argument applies when you use a subarray to receive and set the `SubarraySteering` property to `'Custom'` or use an `phased.NRRectangularPanelArray` System object with each panel as a subarray.

Data Types: `double`
Complex Number Support: Yes

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`

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`

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`

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`

Positions of scatterers, specified as a real-valued 3-by-Ns 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`

Velocities of scatterers, specified as a real-valued 3-by-Ns matrix. The matrix contains the (vx,vy,vz) positions of scatterers. Each column of the matrix specifies a different scatterer and takes the form `[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`

Scattering coefficients, specified as a complex-valued 1-by-Nsrow 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

Scattering matrices of the scatterers, specified as a complex–valued 2-by-2-by-Ns array where Ns 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

Scatterer orientation axes, specified as a real-valued 3-by-3-by-Ns array where Ns 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

expand all

Received narrowband signal, returned as an M-by-Nr complex-valued matrix. M is the number of samples in the signal, and Nr 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

Received narrowband H-polarization signal, returned as a complex-valued M-by-Nr matrix. M is the number of samples in the signal, and Nr 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 `'Dual'`.

Data Types: `double`
Complex Number Support: Yes

Received narrowband V-polarization signal, returned as a complex-valued M-by-Nr matrix. M is the number of samples in the signal, and Nr 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 `'Dual'`.

Data Types: `double`
Complex Number Support: Yes

Channel response, returned as an Nt-by-Nr-by-Nc complex-valued array.

• Nt is the number of transmitting array elements.

• Nr is the number of receiving array elements.

• When you specify `SimulateDirectPath` as `false`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

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

Channel response from H-polarization input to H-polarization output returned as a complex-valued Nt-by-Nr-by-Nc array.

• Nt is the number of transmitting array elements.

• Nr is the number of receiving array elements.

• When you specify `SimulateDirectPath` as `false`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

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

Channel response from H-polarization input to V-polarization output returned as a complex-valued Nt-by-Nr-by-Nc array.

• Nt is the number of transmitting array elements.

• Nr is the number of receiving array elements.

• When you specify `SimulateDirectPath` as `false`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

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

Channel response from V-polarization input to H-polarization output returned as a complex-valued Nt-by-Nr-by-Nc array.

• Nt is the number of transmitting array elements.

• Nr is the number of receiving array elements.

• When you specify `SimulateDirectPath` as `false`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

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

Channel response from V-polarization input to V-polarization output returned as a complex-valued Nt-by-Nr-by-Nc array.

• Nt is the number of transmitting array elements.

• Nr is the number of receiving array elements.

• When you specify `SimulateDirectPath` as `false`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

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

Path delays, returned as a 1-by-NC 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`, Nc = Ns, the number of scatterers.

• When you specify `SimulateDirectPath` as `true`, Nc = Ns + 1 to account for the direct path.

#### Dependencies

To enable this argument, set the `ChannelResponseOutputPort` property to `true`.

Data Types: `double`

## Examples

expand all

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);`

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```

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```

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 ```

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