The uniform linear array (ULA) arranges identical sensor elements
along a line in space with uniform spacing. You can design a ULA with `phased.ULA`

.
When you use this object, you must specify these aspects of the array:

Sensor elements of the array

Spacing between array elements

Number of elements in the array

Create and view a ULA with two isotropic antenna elements separated by 0.5 meters:

hula = phased.ULA('NumElements',2,'ElementSpacing',0.5); viewArray(hula);

You can return the coordinates of the array sensor elements
in the form `[x;y;z]`

by using the `getElementPosition`

method.
See Rectangular Coordinates for toolbox
conventions.

sensorpos = getElementPosition(hula);

`sensorpos`

is a 3-by-2 matrix with each column
representing the position of a sensor element. Note that the *y*-axis
is the array axis. The positive *x*-axis is the array
look direction (0 degrees broadside). The elements are symmetric with
the respect to the phase center of the array.

The default element for a ULA is the `phased.IsotropicAntennaElement`

object.
You can specify an alternative element by changing the `Element`

property.

To obtain the responses of your array elements, use the array's `step`

method.

% Construct antenna for the array elements hant = phased.IsotropicAntennaElement(... 'FrequencyRange',[3e8 1e9]); hula = phased.ULA('NumElements',2,'ElementSpacing',0.5,... 'Element',hant); % Obtain element responses at 1 GHz freq = 1e9; % for azimuth angles from -180:180 azangles = -180:180; % elementresponses elementresponses = step(hula,1e9,azangles);

`elementresponses`

is a 2-by-361 matrix where
each column contains the element responses for the 361 azimuth angles.
Because the elements of the ULA are isotropic antennas, `elementresponses`

is
a matrix of ones.

To determine the signal delay in seconds between array elements,
use `phased.ElementDelay`

.
The incident waveform is assumed to satisfy the far-field assumption.

The following example computes the delay between elements of
a 4-element ULA for a signal incident on the array from –90
degrees azimuth and zero degrees elevation. The delays are computed
with respect to the phase center of the array. By default, `phased.ElementDelay`

assumes
that the incident waveform is an electromagnetic wave propagating
at the speed of light.

% Construct 4-element ULA using value-only syntax hula = phased.ULA(4); hdelay = phased.ElementDelay('SensorArray',hula); tau = step(hdelay,[-90;0]);

`tau`

is a 4-by-1 vector of delays with respect
to the phase center of the array, which is the origin of the local
coordinate system `[0;0;0]`

. See Global and Local Coordinate Systems for
a description of global and local coordinate systems. Negative delays
indicate that the signal arrives at an element before reaching the
phase center of the array. Because the waveform arrives from an azimuth
angle of –90 degrees, the signal impinges on the first and
second elements of the ULA before it reaches the phase center resulting
in negative delays.

If the signal is incident on the array at 0 degrees broadside from a far-field source, the signal illuminates all elements of the array simultaneously resulting in zero delay.

tau = step(hdelay,[0;0]);

If the incident signal is an acoustic pressure waveform propagating
at the speed of sound, you can calculate the element delays by specifying
the `PropagationSpeed`

property.

hdelay = phased.ElementDelay('SensorArray',hula,... 'PropagationSpeed',340); tau = step(hdelay,[90;0]);

In the preceding code, the propagation speed is set to 340 m/s, which is the approximate speed of sound at sea level.

The *steering vector* represents the relative
phase shifts for the incident far-field waveform across the array
elements. You can determine these phase shifts with the `phased.SteeringVector`

object.

For a single carrier frequency, the steering vector for a ULA
consisting of *N* elements is:

$$\left(\begin{array}{c}{e}^{-j2\pi f{\tau}_{1}}\\ {e}^{-j2\pi f{\tau}_{2}}\\ {e}^{-j2\pi f{\tau}_{3}}\\ .\\ .\\ .\\ {e}^{-j2\pi f{\tau}_{N}}\end{array}\right)$$

where τ_{n} denotes the time delay
relative to the array phase center at the n-th array element.

Compute the steering vector for a 4-element ULA with an operating frequency of 1 GHz. Assume that the waveform is incident on the array from 45 degrees azimuth and 10 degrees elevation.

```
hula = phased.ULA(4);
hsv = phased.SteeringVector('SensorArray',hula);
sv = step(hsv,1e9,[45; 10]);
```

You can obtain the steering vector with the following equivalent code.

```
hdelay = phased.ElementDelay('SensorArray',hula);
tau = step(hdelay,[45;10]);
exp(-1j*2*pi*1e9*tau)
```

To obtain the array response, which is a weighted-combination
of the steering vector elements for each incident angle, use `phased.ArrayResponse`

.

Construct a two-element ULA with elements spaced at 0.5 m. Obtain
the array's magnitude response (absolute value of the complex-valued
array response) for azimuth angles `-180:180`

and
plot the normalized magnitude response in decibels.

hula = phased.ULA('NumElements',2,'ElementSpacing',0.5); azangles = -180:180; har = phased.ArrayResponse('SensorArray',hula); resp = abs(step(har,1e9,azangles)); plot(azangles,mag2db((resp/max(resp)))); grid on; title('Azimuth Cut at Zero Degrees Elevation'); xlabel('Azimuth Angle (degrees)');

Visualize the array response using the `plotResponse`

method.
This example uses options to create a 3-D plot of the response in *u*/*v* space;
other plotting options are available.

figure; plotResponse(hula,1e9,physconst('LightSpeed'),... 'Format','UV','RespCut','3D')

You can simulate the effects of phase shifts across your array
using the `collectPlaneWave`

method.

The `collectPlaneWave`

method modulates input
signals by the element of the steering vector corresponding to an
array element. Stated differently, `collectPlaneWave`

accounts
for phase shifts across elements in the array based on the angle of
arrival. However, `collectPlaneWave`

does not account
for the response of individual elements in the array.

Simulate the reception of a 100-Hz sine wave modulated by a
carrier frequency of 1 GHz at a 4-element ULA. Assume the angle of
arrival of the signal is `[-90; 0]`

.

hula = phased.ULA(4); t = unigrid(0,0.001,0.01,'[)'); % signals must be column vectors x = cos(2*pi*100*t)'; y = collectPlaneWave(hula,x,[-90;0],1e9,physconst('LightSpeed'));

The preceding code is equivalent to the following.

```
hsv = phased.SteeringVector('SensorArray',hula);
sv = step(hsv,1e9,[-90;0]);
y1 = x*sv.';
```

Was this topic helpful?