Documentation

This is machine translation

Translated by Microsoft
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Target Tracking Using Sum-Difference Monopulse Radar

This example shows how to use the phased.SumDifferenceMonopulseTracker System object™ to track a moving target. The phased.SumDifferenceMonopulseTracker tracker solves for the direction of a target from signals arriving on a uniform linear array (ULA). The sum-difference monopulse algorithm requires a prior estimate of the target direction which is assumed to be close to the actual direction. In a tracker, the current estimate serves as the prior information for the next estimate. The target is a narrowband 500 MHz emitter moving at a constant velocity of 800 kph. For a ULA array, the steering vector depends only upon the broadside angle. The broadside angle is the angle between the source direction and a plane normal to the linear array. Any arriving signal is specified by its broadside angle.

Note: This example runs only in R2016b or later. If you are using an earlier release, replace each call to the function with the equivalent step syntax. For example, replace myObject(x) with step(myObject,x).

Create the target platform and define its motion

Assume the target is located at [0,10000,20000] with respect to the radar in the radar's local coordinate system. Assume that the target is moving along the y-axis toward the radar at 800 kph.

x0 = [0,10000,20000].';
v0 = 800;
v0 = v0*1000/3600;
targetplatform = phased.Platform(x0,[0,-v0,0].');

Set up the ULA array

The monopulse tracker uses a ULA array which consists of 8 isotropic antenna elements. The element spacing is set to one-half the signal wavelength.

fc = 500e6;
c = physconst('LightSpeed');
lam = c/fc;
antenna = phased.IsotropicAntennaElement('FrequencyRange',[100e6,800e6],...
    'BackBaffled',true);
array = phased.ULA('Element',antenna,'NumElements',8,...
    'ElementSpacing',lam/2);

Assume a narrowband signal. This kind of signal can be simulated using the phased.SteeringVector System object.

steervec = phased.SteeringVector('SensorArray',array);

Tracking Loop

Initialize the tracking loop. Create the phased.SumDifferenceMonopulseTracker System object.

tracker = phased.SumDifferenceMonopulseTracker('SensorArray',array,...
    'PropagationSpeed',c,...
    'OperatingFrequency',fc);

At each time step, compute the broadside angle of the target with respect to the array. Set the step time to 0.5 seconds.

T  = 0.5;
Nsteps = 40;
t = [1:Nsteps]*T;

Setup data vectors for storing and displaying results

rng = zeros(1,Nsteps);
broadang_actual = zeros(1,Nsteps);
broadang_est = zeros(1,Nsteps);
angerr = zeros(1,Nsteps);

Step through the tracking loop. First provide an estimate of the initial broadside angle. In this simulation, the actual broadside angle is known but add an error of five degrees.

[tgtrng,tgtang_actual] = rangeangle(x0,[0,0,0].');
broadang0 = az2broadside(tgtang_actual(1),tgtang_actual(2));
broadang_prev = broadang0 + 5.0; % add some sort of error
  1. compute the actual broadside angle, broadang_actual.

  2. compute the signal, signl, from the actual broadside angle, using the phased.SteeringVector System object.

  3. using the phased.SumDifferenceMonopulseTracker tracker, estimate the broadside angle, broadang_est, from the signal. The broadside angle derived from a previous step serves as an initial estimate for the current step.

  4. compute the difference between the estimated broadside angle, broadang_est, and actual broadside angle, broadang_actual. This is a measure of how good the solution is.

for n = 1:Nsteps
    x = targetplatform(t(n));
    [rng(n),tgtang_actual] = rangeangle(x,[0,0,0].');
    broadang_actual(n) = az2broadside(tgtang_actual(1),tgtang_actual(2));
    signl = steervec(fc,broadang_actual(n)).';
    broadang_est(n) = tracker(signl,broadang_prev);
    broadang_prev = broadang_est(n);
    angerr(n) = broadang_est(n) - broadang_actual(n);
end

Results

Plot the range as a function of time showing the point of closest approach.

plot(t,rng/1000,'-o')
xlabel('time (sec)')
ylabel('Range (km)')

Plot the estimated broadside angle as a function of time.

plot(t,broadang_actual,'-o')
xlabel('time (sec)')
ylabel('Broadside angle (deg)')

A monopulse tracker cannot solve for the direction angle if the angular separation between samples is too large. The maximum allowable angular separation is approximately one-half the null-to-null beamwidth of the array. For an 8-element, half-wavelength-spaced ULA, the half-beamwidth is approximately 14.3 degrees at broadside. In this simulation, the largest angular difference between samples is

maxangdiff = max(abs(diff(broadang_est)));
disp(maxangdiff)
    4.9546

Therefore, the angular separation between samples is less than the half-beamwidth.

Plot the angle error. This is the difference between the estimated angle and the actual angle. The plot shows a very small error, on the order of microdegrees.

plot(t,angerr,'-o')
xlabel('time (sec)')
ylabel('Angle error (deg)')

See Also

Functions

System Objects

Was this topic helpful?