This release adds phased array processing to Simulink®. You can use Simulink to model from end-to-end the transmission, propagation, reception, and detection of signals from antenna and microphone arrays. Over forty blocks are available in 7 libraries with these capabilities.
|Phased Array Library||Purpose|
|Beamforming||Conventional and adaptive beamformers, such as LCMV and MVDR|
|Detection||Detection algorithms, including matched filtering and CFAR|
|Direction of Arrival||DOA algorithms, including beamscan, MUSIC, and ESPRIT|
|Environment||Clutter models, jammers, and target models|
|STAP||Space-time adaptive processing|
|Transmitters and Receivers||Arrays for transmitting and receiving|
|Waveforms||Signal waveforms, such as Linear FM, FMCW, and rectangular|
This release adds directivity methods to each antenna and microphone System object™ and each array, replicated subarray, and partitioned array System object. Directivity is a useful measure of performance for antenna and microphone elements and arrays of elements. Using these methods, you can calculate the directivity values for different directions and frequencies. For examples using the new methods for several System objects, see these pages.
The NoiseBandwidth property of the phased.ReceiverPreamp System object is obsolete and may be removed in a future release. This property is not used in any computation. As of this release, a warning message will be displayed when phased.ReceiverPreamp is invoked with the NoiseBandwidth property specified. To suppress this message, type warning off phased:system:System:NoiseBandwidthWarning at the command line at any time. Alternatively, you can include this command in your startup.m script or other scripts that use phased.ReceiverPreamp.
To avoid future incompatibility, remove all occurrences of the NoiseBandwidth property.
In the RangeMethod property of the phased.RangeDopplerResponse System object, the 'Dechirp' value has been renamed to 'FFT' value. This change is a name change only. The 'Dechirp' value name will be removed in a future release.
When using the RangeMethod property in your code, change all occurrences of 'Dechirp' to 'FFT'.
You can plot the locations of the grating lobes of uniform linear arrays using the new ULA System object method plotGratingLobeDiagram. For uniform rectangular arrays, you use the URA System object method plotGratingLobeDiagram. Using grating lobe diagrams, you can visualize the grating-lobe-free scan region of the array.
The sensorArrayAnalyzer app also provides an option for plotting grating lobe diagrams for uniform linear arrays, uniform rectangular arrays, uniform hexagonal arrays, and circular planar arrays. For example, here is the grating lobe diagram of a spatially undersampled 4-by-4 URA steered towards 35° azimuth.
In R2014a, you have a directivity plotting option for all sensor elements, arrays, and subarrays. Directivity patterns help you analyze sensor element and array performance. To plot the directivity, choose 'dbi' for the Unit parameter value of the plotResponse method.
The directivity pattern of an array takes into account the directivity pattern of its constituent sensors. Examples of how to create directivity pattern plots for selected sensor elements, arrays and subarrays can be found here.
The sensorArrayAnalyzer app also plots 2D and 3D array directivity patterns. You can plot array directivity patterns for all supported array types by choosing 2D Array Directivity or 3D Array Directivity from the Visualization drop-down list. When you plot 2D directivities, you can choose the azimuth and elevation angles at which the cuts are taken. These plots replace the 2D and 3D array response plots. Here is an example of a directivity pattern plot of a 10-element uniform linear array.
In R2014a, there are significant modifications and additions to the sensorArrayAnalyzer app.
You can specify any array geometry by choosing Arbitrary Geometry from the Array Type drop-down list. Then, you specify the element positions in the Element Position field and the element normal angles in the Element Normal field. You can enter the element positions and normal angles directly or use MATLAB® variables and arrays defined at the command prompt.
You can define your own antenna type by choosing Custom Antennas from the Element Type drop-down list. You must supply a radiation pattern in the Radiation Pattern field. You must also supply values to the Frequency Vector, Frequency Response, Azimuth Angles, and Elevation Angles fields. The azimuth angle dimensions must match the column dimensions of the radiation pattern. The elevation angle dimensions must match the row dimensions of the radiation pattern. You can enter antenna values directly into the app fields or use a MATLAB variable or array defined at the command prompt.
You can plot array directivity patterns for all supported arrays, as described in Visualization of element and array directivity.
You can plot grating lobe diagrams for several types of arrays, as described in Grating lobe diagrams.
You can apply custom taper weights (also known as shading weights) to the array elements for all array geometries. Specify the weights in the Taper field directly or use a MATLAB array defined at the command prompt.
For convenience, you can use MATLAB variables and arrays as entries into some of the app data fields. Instead of typing numerical values into the fields, you can define the values as variables or arrays at the MATLAB command prompt and use the name of the variable or array in the field.
In R2014a, with the radarWaveformAnalyzer app, you can specify the temporal spacing between pulses as either the pulse repetition frequency, PRF, in hertz, or as the pulse repetition interval, PRI, in seconds, where PRI = 1/PRF.
The Type property of the phased.PhaseCodedWaveform System object has been renamed to Code property. This System object creates a phase-coded pulse waveform. The Code property specifies the code that you use in phase modulation. This change is a name change only. The Type property name will be removed in a future release.
To avoid future incompatibility, change all instances of this property name to the new name.
The MATLAB® New > System object menu now has three new class-definition file templates. The Basic template sets up a simple System object. The Advanced template includes additional features of System objects. The Simulink Extension template provides additional customization of the System object for use in the MATLAB System block.
When you create a new kind of System object that has a fixed number of inputs or outputs specified in the stepImpl method, you no longer need to include getNumInputsImpl or getNumOutputsImpl in your class definition file. The correct number of inputs and outputs are inferred from the stepImpl inputs and outputs, respectively.
When you create a new kind of System object, you can use the info method to provide information specific to that object. The infoImpl method, which you include in your class-definition file, now allows varargin as an input argument.
The System object base class, matlab.system.System has been rename to matlab.System. If you use matlab.system.System when defining a new System object, a error message results.
Change all instances of matlab.system.System in your System objects code to matlab.System.
Four new methods have been added to the Propagates mixin class. You use this mixin when creating a new kind of System object for use in the MATLAB System block in Simulink. You use these methods to query the input and specify the output of a System object.
The Phased Array System Toolbox™ lets you generate C/C++ code from your phased-array MATLAB application code using the MATLAB Coder™. You can create your own standalone C/C++ executables, libraries, and MEX functions directly and automatically from code that you have written that uses phased-array System objects and functions. MATLAB Coder supports basic MATLAB language features such as program control, functions, and matrix operations. See About Code Generation for more information on the use of MATLAB Coder with the Phased Array System Toolbox.
In this release, the plotResponse method now lets you plot the radiation pattern with different display ranges and resolutions. Previously, for example, you could only plot the pattern in one degree increments in azimuth and elevation. New display options, AzimuthAngles, ElevationAngles, UGrid, and VGrid, give you freedom to change the display range and resolution of the output in azimuth and elevation or in U/V space. These new options apply to all antenna and microphone elements, arrays and subarrays. For documentation and usage examples, see phased.CosineAntennaElement/plotResponse, phased.URA/plotResponse, and phased.ReplicatedSubarray/plotResponse.
The Weights display option of the plotResponse method has a new feature. This applies to all array, replicated subarray and partitioned array System objects. Previously, you could only specify one weight set for multiple frequencies or a different weight set for each frequency. You can now display the response due to multiple sets of weights for a single frequency. For documentation and examples of how to use this properties, see phased.URA/plotResponse, and phased.ReplicatedSubarray/plotResponse.
The restriction on the range of valid frequencies for all antenna and microphone elements is effectively eliminated by increasing the maximum frequency value to 1020 and setting the minimum value to zero.
The function delayseq now use an internal FFT length equal to a power of two.
This change in internal logic produces some insignificant numerical differences. No action is required.
The System object base class, matlab.system.System has been replaced by matlab.System. If you use matlab.system.System when defining a new System object, a warning message results.
Change all instances of matlab.system.System in your System objects code to matlab.System.
When defining a new System object, certain restrictions affect your ability to modify a property.
You cannot use any of the following methods to modify the properties of an object:
This restriction is required by code generation, which assumes that these methods do not change any property values. These methods are validation and querying methods that are expected to be constant and should not impact the algorithm behavior.
If any of your class definition files contain code that changes a property in one of the above Impl methods, move that property code into an allowable Impl method. Refer to the System object Impl method reference pages for more information.
When you use the plotResponse method to return a 3‑D display of the element or array response in UV coordinates, the sample coordinates of the displayed data have changed. The data contained in the handle graphics properties, ‘XData', ‘YData', and ‘ZData', are now sampled uniformly in Cartesian UV grid coordinates instead of uniformly in polar grid coordinates. This changed applies to the plotResponse method for all antenna and microphone element System objects and array System objects.
The data is now in uniformly-sampled Cartesian UV coordinates. The plotResponse display appearance remains unchanged.
When you use a conformal array System object, you can specify a single normal direction vector for the case when all the element normal vectors point in the same direction. Previously, the ElementNormal property required you to specify a separate normal direction vector for each element. This syntax applies to the phased.ConformalArray and phased.HeterogeneousConformalArray System objects.
A major enhancement to the Phased Array System Toolbox product for R2013a lets you simulate the transmission, propagation and reception of polarized electromagnetic waves. Polarization simulation is turned on by setting a new property EnablePolarization in phased.Radiator, phased.Collector, phased.WidebandCollector, phased.RadarTarget, phased.SteeringVector and phased.ArrayResponse System objects. Two new types of antennas specifically for polarized waves are introduced:
phased.ShortDipoleAntennaElement models a short dipole antenna element.
phased.CrossedDipoleAntennaElement models a crossed-dipole antenna element.
You can test whether an antenna or array of antennas can be used to simulate polarization by invoking the isPolarizationCapable method. Only phased.ShortDipoleAntennaElement, phased.CrossedDipoleAntennaElement, and phased.CustomAntennaElement support polarization. Polarization properties of arrays depend upon the properties of their constituent antenna elements.
The phased.CustomAntennaElement System object has several new properties for polarization. You can use the SpecifyPolarizationPattern property to specify whether to use a horizontal or vertical radiation pattern or a combined pattern and then specify HorizontalMagnitudePattern, HorizontalPhasePattern, VerticalMagnitudePattern, and/or VerticalPhasePattern to create the pattern itself.
Changes have been made to the step and plotResponse methods for antenna elements and arrays. With polarization enabled, the step method returns a struct instead of a data array. The plotResponse method plots the horizontal polarization response, the vertical polarization response or a combined polarization response when you set the name-value property Polarization to H, V or Combined. This applies to only arrays and antennas that are capable of polarization. When an antenna or array is not capable of polarization, a fourth option, None, is required.
The phased.RadarTarget System object lets you model the response of a target to a polarized field by invoking the EnablePolarization property. The new Mode property allows for monostatic or bistatic antenna-target configurations. You can set the target's complex 2-by-2 radar cross-section matrix using the new ScatteringMatrix property. The scattering matrix contains the HH, HV, VH, and VV responses of the target.
Summary of Phased Array Polarization Capabilities
|Category||System Objects||New and Modified Properties||New and Modified Methods|
|Antennas and Microphone Elements||phased.CosineAntennaElement|
|Array Geometries and Analysis||phased.ConformalArray|
|Signal Radiation and Collection||phased.Collector|
|Environment and Target Models||phased.RadarTarget||EnablePolarization|
To support polarization simulation analysis, this release includes new utility functions:
|polellip||Parameters of ellipse traced out by tip of a polarized field vector|
|polratio||Ratio of vertical to horizontal linear polarization components of a field|
|stokes||Stokes parameters of polarized field|
|circpol2pol||Convert circular component representation of field to linear component representation|
|pol2circpol||Convert linear component representation of field to circular component representation|
|polsignature||Radar cross section polarization signature|
|rotx||Rotation matrix for rotations around x-axis|
|roty||Rotation matrix for rotations around y-axis|
|rotz||Rotation matrix for rotations around z-axis|
|sph2cartvec||Convert vector from spherical basis components to Cartesian components|
|cart2sphvec||Convert vector from Cartesian components to spherical representation|
|azelaxes||Spherical basis vectors in 3-by-3 matrix form|
This release adds element taper (array weighting) support to phased.ULA, phased.URA , and phased.ConformalArray System objects using the new Taper property. Tapers can be complex-valued coefficients. Real-valued tapers are usually used, for example, to reduce sidelobe levels; complex tapers are useful for modeling phase perturbations. A new method, getTaper, lets you retrieve the taper values. The method, viewArray, has been modified to display the array with taper values shown.
Sensor arrays can now be created to have different antenna patterns assigned to different sensors. These are called heterogeneous arrays. To enable this capability, three new system objects are being introduced, phased.HeterogeneousULA, phased.HeterogeneousURA, and phased.HeterogeneousConformalArray. Heterogeneous arrays let you model, for example, cross-element coupling effects or pattern perturbations. You can specify the types of elements you want in the array using the ElementSet property and then assign a type to each sensor location using the ElementIndices property.
R2013a introduces the first three Phased Array System Toolbox apps:
radarEquationCalculator starts the Radar Equation Calculator which lets you solve for any one of Target Range, Peak Transmit Power, or SNR from the well-known radar equation. Alternatively, you can start Radar Equation Calculator by selecting it from the SIGNAL PROCESSING AND COMMUNICATIONS section of the Apps tab in the MATLAB toolstrip.
radarWaveformAnalyzer invokes the Radar Waveform Analyzer which can plot the shape of five common waveforms as well as their spectra and ambiguity functions. Alternatively, you can start the Radar Waveform Analyzer app by selecting it from the SIGNAL PROCESSING AND COMMUNICATIONS section of the Apps tab in the MATLAB toolstrip.
sensorArrayAnalyzer starts Sensor Array Analyzer to display the geometry of eight different common array configurations. It can also plot the 2-D and 3-D array responses. The user can set the number of array elements, element types, and element spacings and other parameters. Alternatively, you can start the Sensor Array Analyzer app by selecting it from the SIGNAL PROCESSING AND COMMUNICATIONS section of the Apps tab in the MATLAB toolstrip.
New radar analysis tools, blakechart and radarvcd, plot radar range-height-angle (Blake) charts and vertical coverage diagrams. You can use these radar design tools to predict the maximum radar range. This function employs the CRPL Exponential Reference Atmosphere model of the refractive index of the atmosphere.
This new feature of phased.CustomAntennaElement lets you specify frequency-dependent antenna patterns. You do so by creating a 3D array containing pattern values for azimuth, elevation and frequency.
You can now use the phased.gpu.ConstantGammaClutter System object to accelerate clutter simulations with all antenna types not just isotropic. This System object typically runs faster than phased.ConstantGammaClutter. However, there is no GPU support for clutter modeling of polarized waves. phased.gpu.ConstantGammaClutter requires a license for the Parallel Computing Toolbox™ and a GPU-enabled computer.
These new functions give you tools to compute narrowband beamformer weights without requiring the system object framework:
steervec computes the steering vector for a narrowband conventional 1D, , or 3D beamformer of arbitrary shape. The antenna elements are assumed to be isotropic. Inputs to this function are the element positions in units of wavelength and the directions-of-arrival of the incoming signals.
cbfweights computes the weights for a narrowband conventional 1D, , or 3D beamformer of arbitrary shape. The antenna elements are assumed to be isotropic. Inputs to this function are the element positions in units of wavelength and the directions-of-arrival of the incoming signals. The weights produced by cbfweights equal those produced by steervec divided by the number of elements in the array.
mvdrweights returns the weights for a narrowband minimum variance distortionless response (MVDR) beamformer. Inputs to this function are the element positions in units of wavelength, the directions-of-arrival of the incoming signals, and the sensor covariance matrix.
lcmvweights returns the weights for a narrowband linear constraint minimum variance (LCMV) beamformer. Inputs are the signal covariance matrix, the desired responses, and the constraint matrix.
sensorcov returns the received spatial covariance matrix for narrowband plane wave signals arriving at a sensor array. Inputs are the sensor element positions in units of wavelength and the directions-of-arrival of the incoming signals. Optional inputs are the sensor noise and signal covariance matrices.
These new functions allow you to compute directions-of-arrival (DOA) of narrowband signals for uniform line arrays without requiring the use of the system object framework.
rootmusicdoa computes, using the Root MUSIC algorithm, a vector of estimated arrival directions of multiple signals. This estimator uses the sensor covariance matrix and requires that the number of signals be a known value.
espritdoa computes, using the TLS ESPRIT algorithm, a vector of estimated arrival directions of multiple signals. This estimator uses the sensor covariance matrix and requires that the number of signals be a known value.
aictest estimates the number of signals arriving at an array using the Akaike Information Criterion test. This estimator uses a set of snapshots taken at each sensor.
mdltest estimates the number of signals arriving at an array using the Minimum Description Length test. This estimator uses a set of snapshots taken at each sensor.
spsmooth performs spatial smoothing (averaging) of a covariance matrix using maximum overlapped subarrays.
The VisibleRegion property of the phased.ESPRITEstimator System object will be removed in a future release.
In the future, users will have to remove the use of this property from their code.
The index order of the elements of a uniform rectangular array as constructed in phased.URA has changed with this release. Instead of row-major order, elements are stored in column-major order. This has implications for the size and shape of an array. The size of the array is still specified by the Size property which is a 1-by-2 integer vector (or a single integer for square arrays). This vector is now interpreted as [NumberOfRows, NumberOfColumns]. The corresponding ElementSpacing property is a 1-by-2 vector containing the distance between elements (in meters) as [SpacingBetweenRows, SpacingBetweenColumns]. If ElementSpacing is a scalar, the distance along the columns and rows is the same. The following figure shows how the indexing and shape of an array are changed with this release by using a 6-element rectangular array as an example. Previously, a [3,2] array would have three columns and two rows; now it has two columns and three rows.
When constructing replicated subarrays using phased.ReplicatedSubarray, the GridSize and GridSpacing properties are used to position the subarrays on a rectangular grid. You specify the dimensions of the grid using the GridSize property and the distance between grid points with GridSpacing property. As with phased.URA, the interpretation of these properties has changed with this release. In this release, GridSize is a 1-by-2 vector in the form of [NumberOfRows NumberOfColumns] gives the number of elements along each column (z-axis) and the number of elements along each row (y-axis). If GridSize is a scalar, the replicated array has the same number of grid points in each row and column. The GridSpacing property can either be 1-by-2 vector in the form of [SpacingBetweenRows SpacingBetweenColumns] or a scalar (units are meters). If GridSpacing is a scalar, the distance along the rows and columns is the same. The following figure shows how the indexing and shape of a replicated subarray are changed with this release using a GridSize of [1,2]. This creates a 1-by-2 grid of subarrays as shown on the right-hand side of the figure.
These changes make antenna array indexing consistent with the MATLAB convention. To insure that the user is aware of this important change, a warning message will be displayed when phased.URA are invoked. This message may be suppressed by typing warning off phased:system:array:SizeConventionWarning at the command line at any time or by including it in your startup.m script and other scripts. A similar warning appears when phased.ReplicatedSubarray is invoked. Type warning off phased:system:array:GridConventionWarning to suppress this message.
Since data is now stored differently, results will generally differ from that of previous releases for the same input. In most cases however, interchanging the order of entries in the Size and ElementSpacing vectors for phased.URA and the GridSize and GridSpacingvectors for phased.ReplicatedSubarray will give the same results. If you need to look at the output of individual array elements, then there will be some differences.
Phased Array System Toolbox supports the MATLAB Compiler™ for all functions and System objects. Compiler support does not extend to any of the toolbox apps.
The processInputSizeChangeImpl method allows you to specify actions to take when an input to a System object you have defined changes size. If an input changes size after the first call to step, the actions defined in processInputSizeChangeImpl occur when step is next called on that object
A change in the phased.ConstantGammaClutter System object facilitates performing Monte Carlo simulations with Parallel Computing Toolbox constructs, such as parfor. For details about this change, see the description of random number stream usage that follows.
The new —phased.gpu.ConstantGammaClutter System object simulates clutter on a GPU. This System object typically runs faster than phased.ConstantGammaClutter. Using phased.gpu.ConstantGammaClutter requires a license for Parallel Computing Toolbox software.
The phased.FMCWWaveform System object models a frequency modulated continuous wave (FMCW) waveform.
These functions help you determine appropriate property values for phased.FMCWWaveform:
These functions help you simulate and analyze systems that process FMCW waveforms:
The phased.CFARDetector System object provides a new property named Method. Using this property, you can choose among four CFAR detection algorithms: cell averaging (default), smallest-of cell averaging (SOCA), greatest-of cell averaging (GOCA), and order statistic.
In R2012b, if you save a CFAR detector variable in a MAT-file, you cannot load that variable from the MAT-file in an earlier version. Instead, re-create the variable in the earlier version.
The new sensorsig function simulates plane wave signals received at a phased array. This function facilitates statistical analysis and testing of direction-of-arrival algorithms. The function does not require you to simulate an entire phased array system.
The new phased.RangeDopplerResponse System object generates and plots range-Doppler maps.
The phased.FreeSpace System object models the Doppler shift both within a pulse (fast time) and between successive pulses (slow time). In previous releases, the object modeled only the slow-time Doppler shift.
This enhanced Doppler shift modeling is especially useful for observing range-Doppler coupling in a radar system that uses a linear FM waveform.
The step method of the phased.FreeSpace System object has two additional input parameters:
origin_vel, the velocity of the signal origin
dest_vel, the velocity of the signal destination
To update legacy code that uses this step method, use one of these approaches:
In some cases, the signal origin or signal destination is stationary. If so, set the corresponding velocity input argument to [0; 0; 0].
In other cases, the signal origin or signal destination is moving, and you are using phased.Platform to model the moving platform. In this situation, obtain the velocity vector as an additional output argument from the step method of phased.Platform. Then, specify this velocity vector as an input argument in the step method of phased.FreeSpace. For example, compare the R2012a and R2012b versions of an example, and notice the introduction of the txvel variable in the R2012b version.
You can call viewArray on a phased array to plot the positions, normal directions, and element indices of the elements in the array. For arrays containing subarrays, viewArray can also graphically highlight one or more of the subarrays.
The System objects affected are:
For more information, see the reference pages for:
System objects in Phased Array System Toolbox software that rely on a random number generator now behave differently when you set the SeedSource property to 'Auto':
The object uses the global stream of random numbers instead of a private stream. This change is useful if you are performing the computations in a set of Monte Carlo trials involving Parallel Computing Toolbox software. In that situation, the global stream is more suitable than a stream that the System object manages internally.
The reset method does not reset the random number generator.
The System objects affected by this change are:
The following compatibility considerations apply to System objects that existed in earlier releases, if your legacy code configures the objects with the SeedSource property set to 'Auto'.
In operations involving the System objects, the specific random numbers in R2012b differ from the random numbers in earlier releases.
If your code later performs an arbitrary operation that uses the global random number stream, this operation also uses different random numbers compared to earlier releases.
In some cases, your code may rely on operations in earlier releases that reset or restore the random number generator while loading, cloning, or resetting objects. If so, you should update your code to reset or restore the global stream yourself.
A subarray is an accessible subset of array elements. The following new System objects enable you to create arrays that contain subarrays:
The following table lists existing System objects that now support operations on arrays that contain subarrays. Each of the objects in the table has a property called SensorArray or Sensor. You can set that property to an array object that contains subarrays. Also, some of the objects in the table support subarray steering through a new input argument, STEERANGLE, in the step method.
|System Object||SensorArray or Sensor Can Contain Subarrays||step Syntax Can Include Subarray Steering|
For more information about using subarrays, see Subarrays Within Arrays.
The IncludeElementResponse property of the phased.SteeringVector System object is no longer tunable in V1.2 (R2012a). This change facilitates support for arrays containing subarrays.
You may have code from an earlier version that tunes the value of the IncludeElementResponse property of a locked steering vector object. If so, the code will produce an error message in R2012a. You can avoid the error message by calling release to unlock the object, or by not changing the value of the IncludeElementResponse property.
The following new features help you perform pulse compression on linear frequency modulation (FM) waveforms using stretch processing:
Stretch processing is sometimes called deramping or dechirping.
For more information about using stretch processing, see Stretch Processing.
Several enhancements facilitate performing operations in the u/v coordinate system or in a spherical coordinate system that describes angles using φ and θ instead of azimuth and elevation:
Visualize radiation patterns in u/v space using the plotResponse method for arrays, antenna elements, and microphone elements. To use this feature, include 'Format','UV' in the plotResponse syntax.
Convert coordinates from one coordinate system to another using these new functions:
Convert antenna radiation patterns from one coordinate system to another using these new functions:
The following beamformers support multiple beamforming directions:
You can use this capability to model switched-beam systems.
To indicate multiple beamforming directions, use a matrix instead of a vector for the Direction property of the beamformer object or the ANG input argument of step. In earlier versions, the value required a vector. Now, when you specify multiple beamforming directions, the Y and W outputs of step have an extra matrix dimension.
In V1.2 (R2012a), you can create a MAT-file that stores a beamformer variable specifying multiple directions in the Direction property. However, you cannot load that variable from the MAT-file in an earlier version. As an alternative, you can re-create the variable in the earlier version and specify only one beamforming direction.
The plotResponse method for arrays, antenna elements, and microphone elements has enhancements for use with wideband beamforming applications.
For arrays or elements, plotResponse can plot multiple frequency responses in a three-dimensional waterfall plot. To use this feature, include 'OverlayFreq',false in the plotResponse syntax. The OverlayFreq argument is new.
For arrays, plotResponse can apply weights independently to each frequency in the plot. For example, you can use beamformer weights as in Visualization of Wideband Beamformer Performance. To use this feature, include 'Weights',Value in the plotResponse syntax, where Value is a vector or matrix. R2011b required that the weights be the same for all frequencies in the plot and that Value be a vector.
In the phased.ArrayResponse and phased.ArrayGain System objects, the step method permits the WEIGHTS input argument to be a vector or a matrix. In earlier releases, WEIGHTS is a vector.
The phase shift beamformer offers options for normalizing the beamformer weights. To select an option, set the new WeightsNormalization property of the phased.PhaseShiftBeamformer object to one of these values:
'Distortionless' — The gain toward the beamforming direction is 0 dB. This choice is the default and matches the behavior in earlier versions.
'Preserve power' — The norm of the weights is 1.
In V1.2 (R2012a), if you save a phase shift beamformer variable in a MAT-file, you cannot load that variable from the MAT-file in an earlier version. Instead, re-create the variable in the earlier version.
You can create a linear FM waveform to sweep in an interval that is symmetric about 0 or positive only. To choose the location of the FM sweep interval, set the new SweepInterval property of the phased.LinearFMWaveform object to one of these values:
'Positive' — The waveform sweeps between 0 and B, where B is the sweep bandwidth. This choice is the default and matches the behavior in earlier versions.
'Symmetric' — The waveform sweeps between –B/2 and B/2.
The dutycycle function in the Signal Processing Toolbox™ product replaces the earlier dutycycle function in the Phased Array System Toolbox product. The new function includes both the capabilities of the earlier function and additional new capabilities.
The File menu on the MATLAB desktop now includes a New > System object menu item. This option opens a System object class template, which you can use to define a System object class.
System objects that you define now support inputs that change size at runtime.
System objects that you define now support all MATLAB data types as inputs and outputs.
R2012a adds the new DiscreteState attribute for properties in your System object class definition file. Discrete states are values calculated during one step of an object's algorithm that are needed during future steps.
The following methods have been added:
validateProperties – Checks that the System object is in a valid configuration. This applies only to objects that have a defined validatePropertiesImpl method
getDiscreteState – Returns a struct containing a System object's properties that have the DiscreteState attribute
The base System object class name has changed from matlab.system.System to matlab.System.
The previous matlab.system.System class will remain valid for existing System objects. When you define new System objects, your class file should inherit from the matlab.System class.
The phased.MatchedFilter System object supports spectrum weighting using these window types:
You can also specify a custom window. To do so, write a function that takes the window length as an input argument and returns window coefficients in an output argument.
If you save a phased.MatchedFilter object in a MAT-file in V1.1 (R2011b) and then load the MAT-file in V1.0 (R2011a), the object does not perform spectrum weighting. The Command Window shows this warning:
Warning: While loading an object of class 'phased.MatchedFilter': No public field SpectrumWindow exists for class phased.MatchedFilter.
If you write code in V1.1 (R2011b) that sets or reads any of the following properties of phased.MatchedFilter object, the code produces an error message in V1.0 (R2011a).
The phased.URA System object supports both triangular lattices and rectangular lattices. You use the Lattice property to select the lattice type.
In V1.0 (R2011a), phased.URA supports only rectangular lattices and does not have a Lattice property.
If you save a phased.URA object in a MAT-file in V1.1 (R2011b) and then load the MAT-file in V1.0 (R2011a), the object uses a rectangular lattice. The Command Window shows this warning:
Warning: While loading an object of class 'phased.URA': No public field Lattice exists for class phased.URA.
If you write code in V1.1 (R2011b) that sets or reads the Lattice property of a phased.URA object, the code produces an error message in V1.0 (R2011a).
The plotResponse method can plot multiple frequency responses along an azimuth cut or elevation cut. This method is available for the System objects for array design, antenna elements, and microphone elements. To create a plot of multiple frequency responses, use a plotResponse syntax in which:
FREQ is a row vector.
RespCut either does not appear explicitly, or has the value 'Az' or 'El.
The affected System objects are:
In V1.0 (R2011a), FREQ must be a scalar. The resulting plot shows one frequency response.
The phased.CustomAntennaElement System object now permits more general radiation patterns. The main beam of the pattern is no longer required to point to 0 degrees azimuth and 0 degrees elevation.
The save and clone operations now store all states of the System objects in the phased package. As a result, calling the step method on a loaded or cloned object resumes processing from the state where the original object left off. In V1.0 (R2011a), the loaded or cloned object is unlocked and uninitialized.
If your legacy code exploits the unlocked, uninitialized state of a loaded or cloned object, you should update the code in V1.1 (R2011b). You can use the release method to unlock objects.
You can now create custom System objects in MATLAB. This capability allows you to define your own System objects for time-based and data-driven algorithms, I/O, and visualizations. The System object API provides a set of implementation and service methods that you incorporate into your code to implement your algorithm. See Define New System Objects in the DSP System Toolbox™ documentation for more information.
For version 1.1 (R2011b), some error and warning message identifiers have changed in Phased Array System Toolbox software.
If you have scripts or functions that use message identifiers that changed, you must update the code to use the new identifiers. Typically, message identifiers are used to turn off specific warning messages, or in code that uses a try/catch statement and performs an action based on a specific error identifier.
For example, the 'phased:phased:RootWSFEstimator:ZeroSourceNumber' identifier and the 'phased:phased:RootMUSICEstimator:ZeroSourceNumber' identifier have both changed to 'phased:phased:doa:ZeroSourceNumber'. If your code checks for one of the earlier values, you must update it to check for 'phased:phased:doa:ZeroSourceNumber' instead.
To determine the identifier for a warning, run the following command just after you see the warning:
[MSG,MSGID] = lastwarn;
This command saves the message identifier to the variable MSGID.
To determine the identifier for an error, run the following command just after you see the error:
exception = MException.last; MSGID = exception.identifier;
Phased Array System Toolbox provides algorithms and tools for the design, simulation, and analysis of phased array signal processing systems. These capabilities are provided as MATLAB functions and MATLAB System objects. The system toolbox includes algorithms for waveform generation, beamforming, direction of arrival estimation, target detection, and space-time adaptive processing. The system toolbox lets you build monostatic, bistatic, and multistatic architectures for a variety of array geometries. You can model these architectures on stationary or moving platforms. Array analysis and visualization tools help you evaluate spatial, spectral, and temporal performance. The system toolbox lets you model an end-to-end phased array system or use individual algorithms to process acquired data.
Key features of Phased Array System Toolbox Version 1.0 include:
Algorithms available as MATLAB functions and MATLAB System objects
Monostatic, bistatic, and multistatic phased array system modeling
Array analysis and 3D visualization; physical array modeling for uniform linear arrays, uniform rectangular arrays, and arbitrary conformal arrays on platforms with motion
Broadband and narrowband digital beamforming functions, including MVDR/Capon, LCMV, time delay, Frost, time delay LCMV, and subband phase shift
Space-time adaptive processing algorithms, including displaced phase center array (DPCA), adaptive DPCA, sample matrix inversion (SMI) beamforming, and angle-Doppler response visualization
Direction of arrival algorithms, including MVDR, ESPRIT, Beamscan, Root MUSIC, and monopulse tracking
Waveform synthesis functions for pulsed CW, linear FM, stepped FM, and staggered PRF signals, and waveform visualization tools for ambiguity function and matched filter response
Algorithms for TVG, pulse compression, coherent and non-coherent integration, CFAR processing, plotting ROC curves, and estimating range and Doppler
|Release||Features or Changes with Compatibility Considerations|