Among the exams scheduled in the Medical Engineering course at the University of Rome Tor Vergata there is the course of Wireless Electromagnetics Technologies. The course provides the foundation for current and next generation wireless services, including radio and video transmission, radar tracking, mobile and personal communications, wireless sensor networks, wireless charging, radio frequency identification, and satellite links.

During the lessons I had the opportunity to prepare, together with two other colleagues, an exercise on antenna arrays, for the whole class. The tutorial had to be implemented using **Sensor Array Analyzer**, an application for Matlab that is part of the Phased Array System Toolbox tool. A lesson from the course has been replaced with this tutorial with the aim of highlighting the most important aspects of linear arrays, and possibly also for planar arrays. Below I report the salient points of the exercise.

## Sensor Array Analyzer

Sensor Array Analyzer is an application developed for Matlab. It’s is supplied with the Phased Array System Toolbox. This tool provide instruments to design and simulate beamforming system and sensor array to wireless communication, radar, sonar, acoustic and image diagnostic. It is possibile to model and analyze active and passive array, included subarray and particular geometry. The simulated signals can be transmitted and received by these arrays for the design of beamforming and signal processing algorithms.

__________________

The application has its own graphical interface that allows you to create the array, change some settings and view the most important parameters without resorting to *Command Windows*. It can be opened from the Apps selection or via the` sensorArrayAnalyzer`

command. The GUI is divided into three main sections:

- Parameters
- Geometry
- Characteristcs

To this is added the upper menu bar through which it is possible to activate further functions. In particular, it is convenient to immediately activate the 3D pattern, the 2D elevation and azimuth patterns and the grating diagram. It is convenient to arrange them in a 2×3 grid as in the following figure:

So we can go and set some parameters. We can also export the variable and keep it in the Matlab workspace. We then create a linear alignment of isotropic antennas leaving the parameters recommended by the tool.

## Linear array

Considering a uniform array of isotropic antennas, we can set different variables both from the GUI and by querying the properties of the exported variable. We save the array in the `ula`

variable and from the command windows we can ask for the properties. Below is a snippet with some useful commands, also to be launched individually.

```
f=3e8 %3 MHz
lambda = physconst('LightSpeed')/f
array=ula;
L=(array.NumElements+1)*array.ElementSpacing
% to visualize windows
testelemnt=64;
wvtool(hamming(testelemnt)); %plot hamming window
wvtool(chebwin(testelemnt)); %plot chebyshev
ula.Taper %vector with taper coefficients
```

It is convenient to save the frequency and wavelength in a working variable. Knowing the relationship between wavelength and frequency we can easily calculate it (it will be useful for several subsequent considerations) by exploiting the speed of light stored in Matlab: `physconst ('LightSpeed').`

\lambda ={c\over f}

Then we assign the package exported by the tool to a convenience variable (this can be useful for creating a single code and updating it from time to time). Among the initial parameters, from the GUI but also editable from the array. Properties we find:

*Number of elements*, it contains the number of elements of the array and it is stored inside`array.NumElements`

.*Element spacing*, distance between the elements. It can be expressed both in meters and with respect to the wavelength. Stored inside`array.ElementSpacing`

.*Axis*, that is the direction along which the antennas are arranged*Taper*, possibility of weighing the individual antennas in a different way. We will limit ourselves to uniform arrays but it is possible to use different windows. For example, in the code there are commands to display the Chebyshev and Hamming windows. Vector with the coefficients that weigh the single antennas. stored inside`array.Taper`

.

## Radiation

We can see, in the `Characteristics`

tab, some parameters.

*Directivity**Span*, that is the overall length. The software considers the geometric length`d * N`

to be different from what is used in theory`L = (N + 1) d`

. Where`N + 1`

are the elements, then`N`

the spaces.*Number of elements**First null beamdiwth**Half power beamwith**Side lobe level*, represents the difference, in decibels, between the mainlobe and the larger side lobe.

In particular, we can see the difference between the two beamwidths.

We can then create the array in the tool and export it to the workspace. We can create them linear uniform (ULA) and rectangular uniform (URA) by exploiting its isotropic antennas and cosine antennas. We know that the isotropic antenna has an isotropic radiation pattern, consisting of a toroid with the zero aligned to the current, while the cosine antenna has a greater directivity, but is limited to only one lobe of the dipole at λ / 2 (the trend of the current is cosine).

We know that in arrays the overall effect of the fields of the single antennas that give interference between them is reflected in the array factor that acts as an angular filter to the pattern of the single antenna. Furthermore, having seen hominidirectional antennas (isotropic and λ / 2) the contribution of the pattern will be governed by the shape of the array factor. For uniform arrays:

|F|=I_{0} \mid \frac{\sin \frac{N+1}{2}\left(u+u_{0}\right)}{\sin \frac{u+u_{0}}{2}}

So, taking the module, we will get the rectangular diagram that we can project on the radiation pattern (polar diagram). In particular, remembering that the cosine is a periodic but limited quantity, we obtain a limited visibility window.

\left|\cos \psi \right|<1\Longrightarrow u_0-k_0d\leq u+u_0\leq u_0+k_d

Where the two terms are nothing more than convenience variables representing the angular term and the phase term:

u\triangleq k_d\cos \psi \\ u_0\triangleq \alpha d

## Pattern

We can view the 3D radiation pattern both within the app and by calling it from the command window. Starting from a linear array of isotropic antennas we can consider the generic beam pointing, linked to the phase term.

\cos \psi =-{\alpha \over k_0}

Clearly the effect of directionality of the beam is hardly visible with an antenna that radiates on a cone. However, other effects can be seen better, such as the presence of the grating lobe if we increase the space between the antennas too much (or increase the working frequency).

This effect can be seen even better by taking the 2D pattern, precisely the azimuth pattern.

## Broadside ed endfire

It is also possible to recall these figures from the *command windows*.

```
%%plot 3D
pattern(Array, Freq3D , 'PropagationSpeed', PropagationSpeed,'Type','directivity', 'CoordinateSystem', format,'weights', w(:,1));
%%plot 2D
pattern(Array, Frequency, -180:180, cutAngle, 'PropagationSpeed', PropagationSpeed,'Type', 'directivity', 'CoordinateSystem', format ,'weights', w);
pattern(Array, Frequency, cutAngle, -90:90, 'PropagationSpeed', PropagationSpeed,'Type', 'directivity', 'CoordinateSystem', format ,'weights', w);
```

A very interesting thing can be doing a `for`

loop by varying the elements, rather than the pointing angle, rather than spacing between the different antennas.

The different effects that link the spacing to the presence of grating lobes and the variation in the number of secondary lobes are clearly visible.

Turning to a `cosine`

antenna, we can better see the aiming speech. In particular, the two borderline cases broadside and endfire.

## Two-dimensional arrays

Equally interesting are two-dimensional arrays. We can think of these arrays as linear arrays of antennas where these individual antennas are themselves linear arrays of antennas. This is possible by remembering the principle of multiplication of the patterns where the final contribution derives from the array factor and from the single effective heights. Then using uniform lighting and the separable phases along the row and along the column, let’s divide the two array factors on the rows and columns.

\underline E\propto F\cdot \underline h_0\Longrightarrow \begin{cases}F_x\\ F_y\end{cases}

With uniform power supply we will have an array factor which is none other than the two-dimensional Fourier transform of a *rect*. Since the *rect()* is discretized in the single antennas we actually have a series which is therefore always reflected in a *sinc(),* but periodic, coming to supply the rectangular pattern.

We can study the behaviors by varying the elements on the two axes, the spacing and the beam pointing. For example, we can clearly see the effect of the variation of the elements by cycling on the number of elements itself:

```
vec=[4 10 24];
indice=[1 2 3 4; 5 6 7 8;9 10 11 12];
for i=1:numel(vec)
Array = phased.URA('Size',[vec(i) 4],'Lattice','Rectangular','ArrayNormal','x');
Array.ElementSpacing = [0.5 0.5];
rwind = ones(1,4).';
cwind = ones(1,vec(i)).';
taper = rwind*cwind.';
Array.Taper = taper.';
Elem = phased.CosineAntennaElement;
Elem.CosinePower = [1 1];
Elem.FrequencyRange = [0 300000000];
Array.Element = Elem;
Frequency = 300000000;
PropagationSpeed = 300000000;
SteeringAngles = [0;0];
subfigure(3,4,indice(i,1));
% Plot Array Geometry
viewArray(Array,'ShowNormal',false,...
'ShowTaper',false,'ShowIndex','None');
Freq3D = 300000000;
% Find the weights
w = ones(getNumElements(Array), length(Frequency));
subfigure(3,4,indice(i,2));
% Plot 3d graph
format = 'polar';
pattern(Array, Freq3D , 'PropagationSpeed', PropagationSpeed, 'Type','directivity', 'CoordinateSystem', format,'weights', w(:,1));
w = ones(getNumElements(Array), length(Frequency));
subfigure(3,4,indice(i,3));
format = 'polar';
cutAngle = 0;
pattern(Array, Frequency, -180:180, cutAngle, 'PropagationSpeed', PropagationSpeed,'Type', 'directivity', 'CoordinateSystem', format ,'weights', w);
w = ones(getNumElements(Array), length(Frequency));
subfigure(3,4,indice(i,4));
format = 'polar';
cutAngle = 0;
pattern(Array, Frequency, cutAngle, -90:90, 'PropagationSpeed', PropagationSpeed,'Type', 'directivity', 'CoordinateSystem', format ,'weights', w);
pause(0.2)
end
```

Or we can clearly see the aiming effect of the beam that allows you to scan a very precise solid angle.

## Array examples

These concepts, which may seem very theoretical and limited to software, are quickly reflected in the design of real antenna arrays.

## Code

Full codes are available on GitHub: