phased.URA
Uniform rectangular array
Description
To create a Uniform Rectangular Array (URA) System object™:
Create the
phased.URA
object and set its properties.Call the object with arguments, as if it were a function.
To learn more about how System objects work, see What Are System Objects?
Creation
Description
creates a uniform
rectangular array
= phased.URAarray
(URA) System object that models a URA formed from identical isotropic phased array elements.
Array elements are contained in the yz-plane in a
rectangular lattice. The array look direction (boresight) points along the positive
x-axis.
creates an array
= phased.URA(Name
,Value
)array
object with each specified property Name set to the
specified Value. You can specify additional name-value pair arguments in any order as
(Name1
,Value1
, ...,
NameN
,ValueN
). All properties needed to fully
specify this object can be found in Properties.Response of 2-by-2 URA of Short-Dipole Antennas
creates a array
= phased.URA(SZ
,D
,Name
,Value
)phased.URA
array
System object with its Size
property set to SZ
and its ElementSpacing
property set to D
. Other
specified property Names are set to the specified Values. SZ
and
D
are value-only arguments. When specifying a value-only argument,
specify all preceding value-only arguments. You can specify name-value pair arguments in
any order.
Properties
Unless otherwise indicated, properties are nontunable, which means you cannot change their
values after calling the object. Objects lock when you call them, and the
release
function unlocks them.
If a property is tunable, you can change its value at any time.
For more information on changing property values, see System Design in MATLAB Using System Objects.
Element
— phased array element
isotropic antenna element System object with default properties (default) | Phased Array System Toolbox™ antenna, microphone, or transducer element System object | Antenna Toolbox™ antenna System object
Phased array element, specified as a Phased Array System Toolbox antenna, microphone, or transducer element or Antenna Toolbox antenna.
Example: phased.CosineAntennaElement
Size
— Array size
[2 2]
(default) | positive scalar | 1-by-2 vector of positive values
Array size, specified as a 1-by-2 vector of integers or a single integer. containing
the size of the array. If Size
is a 1-by-2 vector, the vector has
the form [NumberOfRows, NumberOfColumns]
. If
Size
is a scalar, the array has the same number of elements in
each row and column. For a URA, array elements are indexed from top to bottom along a
column and continuing to the next columns from left to right. In this illustration, a
Size
value of [3,2]
array has three rows and
two columns.
Example: [3,2]
Data Types: double
ElementSpacing
— Element spacing
[0.5 0.5]
(default) | positive scalar | 1-by-2 vector of positive values
Element spacing, specified as a positive scalar or 1-by-2 vector of positive values.
If ElementSpacing
is a 1-by-2 vector, it has the form
[SpacingBetweenRows,SpacingBetweenColumns]
. See Spacing Between Columns and Spacing Between Rows. If ElementSpacing
is a scalar,
both row and column spacings are equal. Units are in meters.
Example: [0.3, 0.5]
Data Types: double
Lattice
— Lattice type
'Rectangular'
(default) | 'Triangular'
Element lattice type, specified as 'Rectangular'
or
'Triangular'
. When you set the Lattice
property to 'Rectangular'
, all elements of the URA are aligned in
both row and column directions. When you set the Lattice
property
to 'Triangular'
, elements in even rows are displaced toward the
positive row axis direction. The displacement is one-half the element spacing along the
row.
Example: 'Triangular'
Data Types: char
| string
ArrayNormal
— Array normal direction
'x'
(default) | 'y'
| 'z'
Array normal direction, specified as one of 'x'
, 'y'
, or 'z'
. URA elements lie in a plane orthogonal to the selected array normal direction. Element boresight directions point along the array normal direction.
ArrayNormal Property Value | Element Positions and Boresight Directions |
---|---|
'x' | Array elements lie on the yz-plane. All element boresight vectors point along the x-axis. This is the default value. |
'y' | Array elements lie on the zx-plane. All element boresight vectors point along the y-axis. |
'z' | Array elements lie on the xy-plane. All element boresight vectors point along the z-axis. |
Taper
— Element tapers
1 (default) | complex-valued scalar | complex-valued 1-by-MN row vector
Element tapers, specified as a complex-valued scalar, complex-valued
1-by-MN vector, or complex-valued
M-by-N matrix. Tapers are applied to each
element in the sensor array. Tapers are often referred to as element
weights. M is the number of elements along
the z-axis, and N is the number of elements along
y-axis. M and N correspond to
the values of [NumberofRows,NumberOfColumns]
in the
SIze
property. If Taper
is a scalar, the same
taper value is applied to all elements. If the value of Taper
is a
vector or matrix, taper values are applied to the corresponding elements. Tapers are
used to modify both the amplitude and phase of the received data.
Example: [0.4 1 0.4]
Data Types: double
Usage
Syntax
Description
returns the responses of the array elements, RESP
= array(FREQ
,ANG
)RESP
, at the operating
frequencies specified in FREQ
and directions specified in
ANG
.
Note
The object performs an initialization the first time the object 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
FREQ
— Array operating frequencies
length-L row vector of positive values
Array operating frequencies, specified as a length-L row
vector. Typical values are within the range specified by a frequency range property of
the array element. That property is called FrequencyRange
or
FrequencyVector
, depending on the type of array element. The
element has zero response at frequencies outside that range. Units are in Hz.
Data Types: double
ANG
— Array response directions
length-M row vector with real values | 2-by-M matrix with real values
Array response directions, specified as a 2-by-M matrix or length-M row vector.
If ANG
is a 2-by-M matrix, each column of
the matrix specifies the direction in the form [azimuth;
elevation]
. The azimuth angle must lie between –180° and 180°, inclusive.
The elevation angle must lie between –90° and 90°, inclusive.
If ang
is a row vector of length M, each
element specifies the azimuth angle of the direction. In this case, the corresponding
elevation angle is assumed to be 0°.
Units are in degrees.
Output Arguments
RESP
— Voltage responses of phased array elements
N-by-M-by- complex-valued MATLAB® array | MATLAB
struct
Voltage responses of phased array elements. The output depends on whether or not the array supports polarization.
If the array is not capable of supporting polarization, the voltage response,
RESP
, has the dimensions N-by-M-by-L. N is the number of elements in the array. The dimension M is the number of angles specified inANG
. L is the number of frequencies specified inFREQ
. For any element, the columns ofRESP
contain the responses of the array elements for the corresponding direction specified inang
. Each of the L pages ofRESP
contains the responses of the array elements for the corresponding frequency specified infreq
.If the array is capable of supporting polarization, the voltage response
RESP
is a MATLABstruct
containing two fields,RESP.H
andRESP.V
. The field,RESP.H
, represents the array’s horizontal polarization response, whileRESP.V
represents the array’s vertical polarization response. Each field has the dimensions N-by-M-by-L. N is the number of elements in the array, and M is the number of angles specified inANG
. L is the number of frequencies specified inFREQ
. Each column ofRESP
contains the responses of the array elements for the corresponding direction specified inANG
. Each of the L pages ofANG
contains the responses of the array elements for the corresponding frequency specified inFREQ
.
Object Functions
To use an object function, specify the
System object as the first input argument. For
example, to release system resources of a System object named obj
, use
this syntax:
release(obj)
Specific to phased.URA
and other array System objects
beamwidth | Compute and display beamwidth of an array |
collectPlaneWave | Simulate received plane waves at array |
directivity | Compute array directivity |
getElementNormal | Normal vectors for array elements |
getElementPosition | Positions of array elements |
getNumElements | Number of elements in an array |
getTaper | Array element tapers |
isPolarizationCapable | Array polarization capability |
pattern | Plot array directivity and patterns |
patternAzimuth | Plot array directivity or pattern versus azimuth |
patternElevation | Plot array directivity or pattern versus elevation |
perturbations | Perturbations defined on array |
perturbedArray | Apply perturbations to phased array |
perturbedPattern | Display pattern of perturbed array |
plotGratingLobeDiagram | Plot grating lobe diagram of array |
sidelobelevel | Peak and integrated side-lobe levels |
thinnedArray | Create thinned array from full array |
viewArray | View array geometry |
Examples
Response of 2-by-2 URA of Short-Dipole Antennas
Construct a 2-by-2 rectangular lattice URA of short-dipole antenna elements. Then, find the response of each element at boresight. Assume the operating frequency is 1 GHz.
sSD = phased.ShortDipoleAntennaElement; sURA = phased.URA('Element',sSD,'Size',[2 2]); fc = 1e9; ang = [0;0]; resp = step(sURA,fc,ang); disp(resp.V)
-1.2247 -1.2247 -1.2247 -1.2247
Azimuth Response of a 3-by-2 URA at Boresight
Construct a 3-by-2 rectangular lattice URA. By default, the array consists of isotropic antenna elements. Find the response of each element at boresight, 0 degrees azimuth and elevation. Assume the operating frequency is 1 GHz.
array = phased.URA('Size',[3 2]);
fc = 1e9;
ang = [0;0];
resp = array(fc,ang);
disp(resp)
1 1 1 1 1 1
Plot the azimuth pattern of the array.
c = physconst('LightSpeed'); pattern(array,fc,[-180:180],0,'PropagationSpeed',c, ... 'CoordinateSystem','polar','Type','powerdb','Normalize',true)
Compare Triangular and Rectangular Lattice URAs
This example shows how to find and plot the positions of the elements of a 5-row-by-6-column URA with a triangular lattice and a URA with a rectangular lattice. The element spacing is 0.5 meters for both lattices.
Create the arrays.
h_tri = phased.URA('Size',[5 6],'Lattice','Triangular'); h_rec = phased.URA('Size',[5 6],'Lattice','Rectangular');
Get the element y,z positions for each array. All the x coordinates are zero.
pos_tri = getElementPosition(h_tri); pos_rec = getElementPosition(h_rec); pos_yz_tri = pos_tri(2:3,:); pos_yz_rec = pos_rec(2:3,:);
Plot the element positions in the yz-plane.
figure; gcf.Position = [100 100 300 400]; subplot(2,1,1); plot(pos_yz_tri(1,:), pos_yz_tri(2,:), '.') axis([-1.5 1.5 -2 2]) xlabel('y'); ylabel('z') title('Triangular Lattice') subplot(2,1,2); plot(pos_yz_rec(1,:), pos_yz_rec(2,:), '.') axis([-1.5 1.5 -2 2]) xlabel('y'); ylabel('z') title('Rectangular Lattice')
Adding Tapers to an Array
Construct a 5-by-2 element URA with a Taylor window taper along each column. The tapers form a 5-by-2 matrix.
taper = taylorwin(5);
ha = phased.URA([5,2],'Taper',[taper,taper]);
w = getTaper(ha)
w = 10×1
0.5181
1.2029
1.5581
1.2029
0.5181
0.5181
1.2029
1.5581
1.2029
0.5181
Simulate Received Signal at URA
Simulate two received random signals at a 6-element URA. The array has a rectangular lattice with two elements in the row direction and three elements in the column direction. The signals arrive from 10° and 30° azimuth. Both signals have an elevation angle of 0°. Assume the propagation speed is the speed of light and the carrier frequency of the signal is 100 MHz.
array = phased.URA([2 3]);
fc = 100e6;
y = collectPlaneWave(array,randn(4,2),[10 30],fc,physconst('LightSpeed'));
Directivity of Uniform Rectangular Array
Compute the directivity of two uniform rectangular arrays (URA). The first array consists of isotropic antenna elements. The second array consists of cosine antenna elements. In addition, compute the directivity of the first array steered to a specific direction.
Array of isotropic antenna elements
First, create a 10-by-10-element URA of isotropic antenna elements spaced one-quarter wavelength apart. Set the signal frequency to 800 MHz.
c = physconst('LightSpeed'); fc = 3e8; lambda = c/fc; myAntIso = phased.IsotropicAntennaElement; myArray1 = phased.URA; myArray1.Element = myAntIso; myArray1.Size = [10,10]; myArray1.ElementSpacing = [lambda*0.25,lambda*0.25]; ang = [0;0]; d = directivity(myArray1,fc,ang,'PropagationSpeed',c)
d = 15.7753
Array of cosine antenna elements
Next, create a 10-by-10-element URA of cosine antenna elements also spaced one-quarter wavelength apart.
myAntCos = phased.CosineAntennaElement('CosinePower',[1.8,1.8]); myArray2 = phased.URA; myArray2.Element = myAntCos; myArray2.Size = [10,10]; myArray2.ElementSpacing = [lambda*0.25,lambda*0.25]; ang = [0;0]; d = directivity(myArray2,fc,ang,'PropagationSpeed',c)
d = 19.7295
The directivity is increased due to the directivity of the cosine antenna elements.
Steered array of isotropic antenna elements
Finally, steer the isotropic antenna array to 30 degrees in azimuth and examine the directivity at the steered angle.
ang = [30;0]; w = steervec(getElementPosition(myArray1)/lambda,ang); d = directivity(myArray1,fc,ang,'PropagationSpeed',c,... 'Weights',w)
d = 15.3309
The directivity is maximum in the steered direction and equals the directivity of the unsteered array at boresight.
URA Element Normals
Construct three 2-by-2 URA's with element normals along the x-, y-, and z-axes. Obtain the element positions and normal directions.
First, choose the array normal along the x-axis.
sURA1 = phased.URA('Size',[2,2],'ArrayNormal','x'); pos = getElementPosition(sURA1)
pos = 3×4
0 0 0 0
-0.2500 -0.2500 0.2500 0.2500
0.2500 -0.2500 0.2500 -0.2500
normvec = getElementNormal(sURA1)
normvec = 2×4
0 0 0 0
0 0 0 0
All elements lie in the yz-plane and the element normal vectors point along the x-axis (0°,0°).
Next, choose the array normal along the y-axis.
sURA2 = phased.URA('Size',[2,2],'ArrayNormal','y'); pos = getElementPosition(sURA2)
pos = 3×4
0.2500 0.2500 -0.2500 -0.2500
0 0 0 0
0.2500 -0.2500 0.2500 -0.2500
normvec = getElementNormal(sURA2)
normvec = 2×4
90 90 90 90
0 0 0 0
All elements lie in the zx-plane and the element normal vectors point along the y-axis (90°,0°).
Finally, set the array normal along the z-axis. Obtain the normal vectors of the odd-numbered elements.
sURA3 = phased.URA('Size',[2,2],'ArrayNormal','z'); pos = getElementPosition(sURA3)
pos = 3×4
-0.2500 -0.2500 0.2500 0.2500
0.2500 -0.2500 0.2500 -0.2500
0 0 0 0
normvec = getElementNormal(sURA3,[1,3])
normvec = 2×2
0 0
90 90
All elements lie in the xy-plane and the element normal vectors point along the z-axis (0°,90°).
Obtain URA Element Positions
Construct a default URA with a rectangular lattice, and obtain the element positions.
array = phased.URA; pos = getElementPosition(array)
pos = 3×4
0 0 0 0
-0.2500 -0.2500 0.2500 0.2500
0.2500 -0.2500 0.2500 -0.2500
Obtain Number of URA Elements
Construct a default URA, and obtain the number of elements.
array = phased.URA; N = getNumElements(array)
N = 4
Create Tapered URA
Construct a 5-by-2 element URA with a Taylor window taper along each column. Then, draw the array showing the element taper shading.
taper = taylorwin(5);
array = phased.URA([5,2],'Taper',[taper,taper]);
w = getTaper(array)
w = 10×1
0.5181
1.2029
1.5581
1.2029
0.5181
0.5181
1.2029
1.5581
1.2029
0.5181
viewArray(array,'ShowTaper',true)
Short-Dipole URA Supports Polarization
Show that a URA array of phased.ShortDipoleAntennaElement
short-dipole antenna elements supports polarization.
antenna = phased.ShortDipoleAntennaElement('FrequencyRange',[1e9 10e9]); array = phased.URA([3,2],'Element',antenna); isPolarizationCapable(array)
ans = logical
1
The returned value 1
shows that this array supports polarization.
Pattern of 5x7-Element URA Antenna Array
Create a 5x7-element URA operating at 1 GHz. Assume the elements are spaced one-half wavelength apart. Show the 3-D array patterns.
Create the array
sSD = phased.ShortDipoleAntennaElement(... 'FrequencyRange',[50e6,1000e6],... 'AxisDirection','Z'); fc = 500e6; c = physconst('LightSpeed'); lam = c/fc; sURA = phased.URA('Element',sSD,... 'Size',[5,7],... 'ElementSpacing',0.5*lam);
Call the step
method
Evaluate the fields of the first five elements at 45 degrees azimuth and 0 degrees elevation.
ang = [45;0]; resp = step(sURA,fc,ang); disp(resp.V(1:5))
-1.2247 -1.2247 -1.2247 -1.2247 -1.2247
Display the 3-D directivity pattern at 500 MHz in polar coordinates
pattern(sURA,fc,[-180:180],[-90:90],... 'CoordinateSystem','polar',... 'Type','directivity','PropagationSpeed',c)
Display the 3-D directivity pattern at 500 MHz in UV coordinates
pattern(sURA,fc,[-1.0:.01:1.0],[-1.0:.01:1.0],... 'CoordinateSystem','uv',... 'Type','directivity','PropagationSpeed',c)
Azimuth Pattern of 5x7-Element URA Antenna Array
Create a 5x7-element URA of short-dipole antenna elements operating at 1 GHz. Assume the elements are spaced one-half wavelength apart. Plot the array azimuth directivity patterns for two different elevation angles, 0 and 15 degrees. The patternAzimuth
method always plots the array pattern in polar coordinates.
Create the array
sSD = phased.ShortDipoleAntennaElement(... 'FrequencyRange',[50e6,1000e6],... 'AxisDirection','Z'); fc = 1e9; c = physconst('LightSpeed'); lam = c/fc; sURA = phased.URA('Element',sSD,... 'Size',[5,7],... 'ElementSpacing',0.5*lam);
Display the pattern
Display the azimuth directivity pattern at 1 GHz in polar coordinates
patternAzimuth(sURA,fc,[0 15],... 'PropagationSpeed',c,... 'Type','directivity')
Display a subset of angles
You can plot a smaller range of azimuth angles by setting the Azimuth
parameter.
patternAzimuth(sURA,fc,[0 15],... 'PropagationSpeed',c,... 'Type','directivity',... 'Azimuth',[-45:45])
Elevation Pattern of 7x7-Element Acoustic URA
Create a 7x7-element URA of backbaffled omnidirectional transducer elements operating at 1 kHz. Assume the speed of sound in water is 1500 m/s. The elements are spaced less than one-half wavelength apart. Plot the array elevation directivity patterns for three different azimuth angles, -20, 0, and 15 degrees. The patternElevation
method always plots the array pattern in polar coordinates.
Create the array
element = phased.OmnidirectionalMicrophoneElement(... 'FrequencyRange',[20,3000],... 'BackBaffled',true); fc = 1000; c = 1500; lam = c/fc; array = phased.URA('Element',element,... 'Size',[7,7],... 'ElementSpacing',0.45*lam);
Display the pattern
Display the azimuth directivity pattern at 1 GHz in polar coordinates.
patternElevation(array,fc,[-20, 0, 15],... 'PropagationSpeed',c,... 'Type','directivity')
Display a subset of elevation angles
You can plot a smaller range of elevation angles by setting the Elevation
parameter.
patternElevation(array,fc,[-20, 0, 15],... 'PropagationSpeed',c,... 'Type','directivity',... 'Elevation',[-45:45])
Grating Lobe Diagram for Microphone URA
Plot the grating lobe diagram for an 11-by-9-element uniform rectangular array having element spacing equal to one-half wavelength.
Assume the operating frequency of the array is 10 kHz. All elements are omnidirectional microphone elements. Steer the array in the direction 20 degrees in azimuth and 30 degrees in elevation. The speed of sound in air is 344.21 m/s at 21 deg C.
cair = 344.21; f = 10.0e3; lambda = cair/f; microphone = phased.OmnidirectionalMicrophoneElement(... 'FrequencyRange',[20 20000]); array = phased.URA('Element',microphone,'Size',[11,9],... 'ElementSpacing',0.5*lambda*[1,1]); plotGratingLobeDiagram(array,f,[20;30],cair);
Plot the grating lobes. The main lobe of the array is indicated by a filled black circle. The grating lobes in visible and nonvisible regions are indicated by unfilled black circles. The visible region is the region in u-v coordinates for which . The visible region is shown as a unit circle centered at the origin. Because the array spacing is less than one-half wavelength, there are no grating lobes in the visible region of space. There are an infinite number of grating lobes in the nonvisible regions, but only those in the range [-3,3] are shown.
The grating-lobe free region, shown in green, is the range of directions of the main lobe for which there are no grating lobes in the visible region. In this case, it coincides with the visible region.
The white areas of the diagram indicate a region where no grating lobes are possible.
Geometry, Normal Directions, and Indices of URA Elements
This example shows how to display the element positions, normal directions, and indices for all elements of a 4-by-4 square URA.
ha = phased.URA(4); viewArray(ha,'ShowNormals',true,'ShowIndex','All');
More About
Spacing Between Columns
The spacing between columns is the distance between adjacent elements in the same row.
Spacing Between Rows
The spacing between rows is the distance along the column axis direction between adjacent rows.
References
[1] Brookner, E., ed. Radar Technology. Lexington, MA: LexBook, 1996.
[2] Brookner, E., ed. Practical Phased Array Antenna Systems. Boston: Artech House, 1991.
[3] Mailloux, R. J. “Phased Array Theory and Technology,” Proceedings of the IEEE, Vol., 70, Number 3s, pp. 246–291.
[4] Mott, H. Antennas for Radar and Communications, A Polarimetric Approach. New York: John Wiley & Sons, 1992.
[5] Van Trees, H. Optimum Array Processing. New York: Wiley-Interscience, 2002.
Extended Capabilities
C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.
Usage notes and limitations:
pattern
,patternAzimuth
,patternElevation
, andviewArray
object functions are not supported.See System Objects in MATLAB Code Generation (MATLAB Coder).
Version History
Introduced in R2011a
Comando de MATLAB
Ha hecho clic en un enlace que corresponde a este comando de MATLAB:
Ejecute el comando introduciéndolo en la ventana de comandos de MATLAB. Los navegadores web no admiten comandos de MATLAB.
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)