This is machine translation

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

Note: This page has been translated by MathWorks. Click here to see
To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

Simulating Passive Radar Sensors and Radar Interferences

This example shows you how to model and simulate the output of active and passive radar sensors. In this example, you observe how radio frequency (RF) interference impacts the detection performance of a radar. In addition, you use passive radar sensors to estimate the location and type of the RF interference.

Introduction

Assessing tracking performance for radars requires modeling a radio frequency (RF) scenario. This includes:

  • Generating RF emissions

  • Propagating the emissions and reflecting these emissions from platforms

  • Receiving the emissions, calculating interference losses, and generating detections

Create scenario

This example shows you how to perform each of the steps above using a scenario consisting of three platforms:

  1. Airborne platform flying north at 500 kph from the bottom of the scenario

  2. Airborne platform flying south at 600 kph from the top of the scenario

  3. Airborne platform flying east at 700 kph in the middle of the scenario

% Add path to helper files used by this example.
helperPath = fullfile(matlabroot,'examples','fusion','main');
addpath(helperPath);

% Remove path to helper files when 'cleanPath' variable is cleared or deleted.
cleanPath = onCleanup(@()rmpath(helperPath));

% Create a tracking scenario to manage the movement of the platforms.
scene = trackingScenario;

% Set the duration of the scenario to 10 seconds.
scene.StopTime = 10; % s

% Platform 1: Airborne and northbound at 500 kph
spd = 500*1e3/3600; % m/s
wp1 = [0 0 0];
wp2 = [spd*scene.StopTime 0 0];
toa = [0; scene.StopTime];
platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa));

% Platform 2: Airborne and southbound at 600 kph
spd = 600*1e3/3600; % m/s
wp1 = [30e3+spd*scene.StopTime 0 0];
wp2 = [30e3 0 0];
toa = [0; scene.StopTime];
platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa));

% Platform 3: Airborne and eastbound at 700 kph
spd = 700*1e3/3600; % m/s
wp1 = [10e3 1e3 0];
wp2 = [10e3 1e3+spd*scene.StopTime 0];
toa = [0; scene.StopTime];
platform(scene, 'Trajectory', waypointTrajectory('Waypoints', [wp1; wp2], 'TimeOfArrival', toa));

Show the platforms in the scenario.

helperDisplay = helperRadarExampleDisplay(scene);
legend('Ground', 'Platforms');

Radar Detection in the Presence of Interfering Emissions

Often, a radar operates in an environment where other undesirable RF emissions interfere with the waveforms emitted by the radar. When this occurs, the radar will experience a degradation in detection performance in the direction of the interfering signals. Attach an RF emitter to the platform at the bottom of the scenario (the first platform) and a radar to the platform at the top of the scenario (the second platform).

Create an RF emitter

Model an RF emission using a radarEmitter. The emitter is in a forward-looking configuration with an azimuthal field of view of 20 degrees to include the 2 other platforms in the scenario. The effective isotropic radiated power (EIRP) sets the strength of the interfering signal. The waveform type is a user-defined value used to enumerate the various waveform types that are present in the scenario. For this scenario, use the value 0 to indicate a noise waveform type.

% Create the interference emitter.
rfEmitter = radarEmitter(1, 'No scanning', ...
    'FieldOfView', [20 5], ...       % [az el] deg
    'EIRP', 200, ...                 % dBi
    'CenterFrequency', 300e6, ...    % Hz
    'Bandwidth', 30e6, ...           % Hz
    'WaveformType', 0)               % Use 0 for noise-like emissions
rfEmitter = 

  radarEmitter with properties:

        EmitterIndex: 1
          UpdateRate: 1
            ScanMode: 'No scanning'

    MountingLocation: [0 0 0]
      MountingAngles: [0 0 0]

         FieldOfView: [2×1 double]
     MechanicalAngle: 0
           LookAngle: 0
        HasElevation: 0

                EIRP: 200
     CenterFrequency: 300000000
           Bandwidth: 30000000
        WaveformType: 0
      ProcessingGain: 0

Attach the emitter to the first platform.

platEmit = scene.Platforms{1};
platEmit.Emitters = rfEmitter
platEmit = 

  Platform with properties:

       PlatformID: 1
          ClassID: 0
       Trajectory: [1×1 waypointTrajectory]
    PoseEstimator: [1×1 insSensor]
         Emitters: {[1×1 radarEmitter]}
          Sensors: {}
       Signatures: {[1×1 rcsSignature]  [1×1 irSignature]  [1×1 tsSignature]}

Create a monostatic radar

Equip the second platform with a monostatic radar. Use monostaticRadarSensor to model this type of radar. Configure the radar to scan the azimuth sector in front of its platform which includes the other platforms.

% Create a monostatic radar.
radar = monostaticRadarSensor(2, 'Sector', ...
    'UpdateRate', 12.5, ...          % Hz
    'FieldOfView', [2 10]);          % [az el] deg

% Mount the radar so that it scans the sector in front of the second
% platform which includes the interfering signal and the third platform.
radar.MountingAngles = [0 0 0];      % [Z Y X] deg

% Enable the radar's INS input so that it can use the pose estimated by
% the platform's pose estimator to generate detections.
radar.HasINS = true;

% Enable the radar's interference input so that the interference signal
% created by the emitter above can be passed to the radar.
radar.HasInterference = true

% Attach the radar to the second platform.
platRadar = scene.Platforms{2};
platRadar.Sensors = radar;
radar = 

  monostaticRadarSensor with properties:

                  SensorIndex: 2
                   UpdateRate: 12.5000
                     ScanMode: 'Mechanical'

             MountingLocation: [0 0 0]
               MountingAngles: [0 0 0]

          MaxUnambiguousRange: 100000
    MaxUnambiguousRadialSpeed: 200
                  FieldOfView: [2×1 double]
        MaxMechanicalScanRate: 75
         MechanicalScanLimits: [-45 45]
              MechanicalAngle: 0
                    LookAngle: 0

         DetectionProbability: 0.9000
               FalseAlarmRate: 1.0000e-06

  Use get to show all properties

Update the display to show the platforms and the radar and the emitter in the scenario.

close(helperDisplay);
helperDisplay = helperRadarExampleDisplay(scene);
title('Radar detection with an interfering emitter');

In the preceding figure, the platform carrying the forward-looking radar is shown as a blue diamond, with the radar's current field of view as a blue region originating from the platform. At the bottom of the figure, the platform carrying the interfering RF emission is shown as a yellow diamond, with the emitter's current field of view shown as a corresponding yellow region. Platforms without any emitters or sensors attached to them are referred to as targets and are displayed as black triangles.

Simulate detections

Configure the scenario's update rate to match the update rate of the sensor and emitter systems in the scenario. A common update rate is found by using the local function commonRate.

% Calculate a common rate to advance the scenario.
rate = commonRate(scene.Platforms); % Hz

Advance the scenario at the common update rate until the scenario's StopTime has been reached.

scene.UpdateRate = rate
scene = 

  trackingScenario with properties:

        UpdateRate: 12.5000
          StopTime: 10
    SimulationTime: 0
         IsRunning: 1
         Platforms: {1×3 cell}

For each step in the following loop use:

  1. advance to move all of the platforms according to their trajectories.

  2. emit to update the emissions transmit direction from platEmit.

  3. radarChannel to propagate the emissions directly to each platform in the scenario that lies within the emitter's field of view. Each platform that receives a direct path emission generates a single-bounce reflection that is also propagated to every other platform as a reflected emission.

  4. detect to generate detections from the emissions received at platRadar.

This propagation of the emitter's emissions from the emitter to the radar sensor are illustrated in the following image.

% Set the random seed for repeatable results.
rng(2018);

plotDets = {};
while advance(scene)

    % Get current simulation time.
    time = scene.SimulationTime;

    % Emit the RF signal.
    [txEmiss, txConfig] = emit(platEmit, time);

    % Reflect the emitted signal off of the platforms in the scenario.
    reflEmiss = radarChannel(txEmiss, scene.Platforms);

    % Generate detections from the monostatic radar sensor.
    [dets, ~, config] = detect(platRadar, reflEmiss, time);

    % Reset detections every time the radar completes a sector scan.
    if config.IsScanDone
        % Reset
        plotDets = dets;
    else
        % Buffer
        plotDets = cat(1,plotDets,dets);
    end

    % Update display with current beam positions and detections.
    helperDisplay(txEmiss,plotDets,config);
end

As shown in the preceding figure, the radar (shown in blue) is only able to detect the target in the middle of the scenario. The detections are shown as blue, filled circles, and are made whenever the radar's field of view (e.g. beam) sweeps across the target. However, when the radar's beam sweeps across the emitting platform (shown in yellow), no detections are generated, since the interference generated by this platform prevents detection by the radar.

Passive Detection of RF Emissions

In the preceding section, the radar was unable to detect the location of the emitting platform because the emissions from that platform masked the radar's own emissions. However, such strong emissions can be detected and identified by passive sensors which listen for RF emissions in the scenario. These sensors are often referred to as electronic support measures (ESM). These sensors typically listen across a broad range of frequencies and attempt to identify unique emitters, the direction of arrival of the emissions from those emitters, and whenever possible, the type of waveform used by the emitter.

Create an ESM sensor

Reuse the scenario from the previous section, but replace the monostatic radar on the first platform with an ESM sensor. Use radarSensor to model the ESM sensor and ensure that the sensor is configured so that its center frequency and bandwidth includes the RF spectrum of the emitter. Otherwise, it will be unable able to detect the emitter.

restart(scene);
esm = radarSensor(1, 'No scanning', ...
    'DetectionMode', 'ESM', ...
    'UpdateRate', 12.5, ...          % Hz
    'MountingAngles', [0 0 0], ...   % [Z Y X] deg
    'FieldOfView', [30 10], ...      % [az el] deg
    'CenterFrequency', 300e6, ...    % Hz
    'Bandwidth', 30e6, ...           % Hz
    'WaveformTypes', 0, ...          % Detect the interference waveform type
    'HasINS', true)
esm = 

  radarSensor with properties:

         SensorIndex: 1
          UpdateRate: 12.5000
            ScanMode: 'No scanning'
       DetectionMode: 'ESM'

    MountingLocation: [0 0 0]
      MountingAngles: [0 0 0]

         FieldOfView: [2×1 double]
     MechanicalAngle: 0
           LookAngle: 0

         Sensitivity: -50
      FalseAlarmRate: 1.0000e-06

  Use get to show all properties

Replace the radar on the second platform with the ESM sensor.

platESM = scene.Platforms{2};
platESM.Sensors = esm;
close(helperDisplay);
helperDisplay = helperRadarExampleDisplay(scene);
title('Passive detection of RF emissions');

% Take a snapshot 2 seconds into the scenario.
snapTime = 2; % s
helperDisplay.GrabFigureFcn = @(scene,fig)helperGrabFigureOnce(scene,fig,snapTime);

In the preceding figure, the radar is replaced by an ESM sensor mounted on the second platform. The ESM sensor's field of view is shown in magenta and includes both the emitting and target platforms.

Now simulate detections using the ESM sensor instead of the radar. You will notice that because the ESM sensor is a passive sensor, it is unable to localize the emitting platform, but indicates the direction of arrival the platform's emissions. These angle-only detections are shown as rays originating from the ESM sensor towards the emitting platform.

% Set the random seed for repeatable results.
rng(2018);

% Set update rate for the scenario to a common rate for the sensors and
% emitters.
rate = commonRate(scene.Platforms); % Hz
scene.UpdateRate = rate;

plotDets = {};
while advance(scene)

    % Get current simulation time.
    time = scene.SimulationTime;

    % Emit the RF signal.
    [txEmiss, txConfig] = emit(platEmit, time);

    % Reflect the emitted signal off of the platforms in the scenario.
    reflEmiss = radarChannel(txEmiss, scene.Platforms);

    % Generate detections from the monostatic radar sensor.
    [dets, ~, config] = detect(platESM, reflEmiss, time);

    % Reset detections every time the radar completes a sector scan.
    if config.IsScanDone
        % Reset
        plotDets = dets;
    else
        % Buffer
        plotDets = cat(1,plotDets,dets);
    end

    % Update display with current beam positions and detections.
    helperDisplay(txEmiss,plotDets,config);
end
title('RF emitter detected by an ESM sensor');

The RF emissions are detected and their direction of arrival is estimated by the ESM sensor. This is shown by the magenta line originating from the sensor and closely passing by the emitter. There is some noise in the estimated angle, which is why the line does not pass directly through the emitter's location.

The ESM sensor classifies the waveform types in its reported detections. For this emitter, it reports the noise waveform type used by the emitter: 0.

dets{1}.ObjectAttributes{1}
ans = 

  struct with fields:

     TargetIndex: 1
    EmitterIndex: 1
    WaveformType: 0
             SNR: 184.7839

Notice that the signal-to-noise ratio (SNR) of the emitted signal detected by the sensor is very large, 185 dB. Because the RF emitter has high power, reflections of the emitted waveform off of the target will also be detected by the ESM sensor. This is seen at 2 seconds in the simulation when the target lies within the emitter's field of view.

% Show the snapshot taken at 2 seconds into the simulation.
showGrabs(helperDisplay, 1);
title('Emitter and target detected by an ESM sensor');

In the preceding figure, emissions are detected from both the emitter and the target, as the target receives energy from the emitter and re-emits that waveform back into the scenario, causing it to be detected by the ESM sensor as well.

Passive Detection of Monostatic Radars

Monostatic radars also emit waveforms into the scenario. Sometimes it is desirable to be able to detect their emissions. To do this, you must model both the emitting and sensing portions of the radar separately. The emitter generates the waveforms which become part of the scenario's RF emissions. These waveforms can then be detected by other sensors, such as the ESM sensor presented in the preceding section.

Reuse the same scenario from the preceding sections. For this scenario, attach a monostatic radar to the platform at the top of the scenario (the second platform), and attach an ESM sensor to the platform at the bottom of the scenario (the first platform). The middle platform remains a target with no emitters or sensors attached to it.

restart(scene);

Create a monostatic radar by modeling both the emitting and sensing portions of the sensor. Use radarEmitter to model the monostatic radar emitter. For this scenario, use 1 to indicate the waveform type used by this radar, where perhaps 1 represents an LFM chirp with some predefined parameters. The waveform type is an enumeration defined by the user to represent the different kinds of waveforms simulated in the scenario. This enables emitters and sensors to know how to process these waveforms to generate detections. For example, if an emitter has a waveform type of 1 and a sensor includes this type in its waveform list, then the sensor will know how to process the emitter's emissions (e.g. using a matched filter) and will detect the emission and realize the processing gain associated with that waveform.

% Create the emitter for the monostatic radar.
radarTx = radarEmitter(2, 'Sector', ...
    'UpdateRate', 12.5, ...          % Hz
    'MountingAngles', [0 0 0], ...   % [Z Y X] deg
    'FieldOfView', [2 10], ...       % [az el] deg
    'CenterFrequency', 300e6, ...    % Hz
    'Bandwidth', 3e6, ...            % Hz
    'ProcessingGain', 50, ...        % dB
    'WaveformType', 1)               % Use 1 to indicate this radar's waveform
radarTx = 

  radarEmitter with properties:

             EmitterIndex: 2
               UpdateRate: 12.5000
                 ScanMode: 'Mechanical'

         MountingLocation: [0 0 0]
           MountingAngles: [0 0 0]

              FieldOfView: [2×1 double]
    MaxMechanicalScanRate: 75
     MechanicalScanLimits: [-45 45]
          MechanicalAngle: 0
                LookAngle: 0
             HasElevation: 0

                     EIRP: 100
          CenterFrequency: 300000000
                Bandwidth: 3000000
             WaveformType: 1
           ProcessingGain: 50

Use radarSensor to model the sensing portion of the radar which receives the RF emissions in the scenario, identifies the emissions that corresponds to the monostatic emitter's waveform type, and generates detections from these received emissions. Emissions which do not match the emitter's waveform type are treated as interference.

When using radarSensor to model the sensing portion of a monostatic radar, you must set the DetectionMode property of the sensor to Monostatic. This tells the sensor to use the emitter's configuration when processing the received RF emissions.

radarRx = radarSensor(2, ...
    'DetectionMode', 'Monostatic', ...
    'EmitterIndex', radarTx.EmitterIndex, ...
    'HasINS', true)

% Attach to the radar emitter and sensor to the second platform.
platRadar = scene.Platforms{2};
platRadar.Emitters = radarTx;
platRadar.Sensors = radarRx;
radarRx = 

  radarSensor with properties:

                  SensorIndex: 2
                DetectionMode: 'Monostatic'
                 EmitterIndex: 2

          MaxUnambiguousRange: 100000
    MaxUnambiguousRadialSpeed: 200
                    LookAngle: 0

                  Sensitivity: -50
               FalseAlarmRate: 1.0000e-06

  Use get to show all properties

Reuse the ESM sensor from the preceding section, but set the list of known waveform types for the ESM sensor to include the waveform emitted by the radar. If the radar's waveform type is not known to the ESM sensor, it will not be detected.

% Add the radar's waveform to the list of known waveform types for the ESM sensor.
esm.WaveformTypes = [0 1];

% Attach the ESM sensor to the first platform.
platESM = scene.Platforms{1};
platESM.Emitters = {}; % Remove the emitter.
platESM.Sensors = esm;

% Show the configuration of sensors and platforms.
close(helperDisplay);
helperDisplay = helperRadarExampleDisplay(scene);
title('Passive detection of a monostatic radar');

% Take a snapshot 2 seconds into the scenario.
snapTime = 2; % s
helperDisplay.GrabFigureFcn = @(scene,fig)helperGrabFigureOnce(scene,fig,snapTime);

In the preceding figure, the radar is scanning an azimuth sector in front of its platform which includes both the target platform as well as the platform carrying the ESM sensor. The radar will generate detections for both of these platforms when its field of view (shown in blue) sweeps over their location. However, when the radar's beam passes over the location of the ESM sensor, the ESM sensor will detect the radar and will indicate its estimated position by drawing a line originating from the sensor's location.

% Set the random seed for repeatable results.
rng(2018);

platforms = scene.Platforms;
numPlat = numel(platforms);

% Set update rate for the scenario to a common rate for the sensors and emitters.
rate = commonRate(platforms); % Hz
scene.UpdateRate = rate;

plotDets = {};
while advance(scene)

    % Get current simulation time.
    time = scene.SimulationTime;

    % Collect emitted signals.
    txEmiss = {};
    txConfigs = [];
    for iPlat = 1:numPlat
        thisPlatform = platforms{iPlat};

        % Generate signals for each emitter on this platform.
        [theseSigs, theseConfigs] = emit(thisPlatform, time);
        txEmiss = {txEmiss{:}, theseSigs{:}}; %#ok<CCAT>
        txConfigs = [txConfigs; theseConfigs]; %#ok<AGROW>
    end

    % Reflect signals off of platforms in the scenario.
    reflSigs = radarChannel(txEmiss, platforms);

    % Generate detections.
    bufferDets = {};
    rxConfigs = [];
    for iPlat = 1:numPlat
        thisPlatform = platforms{iPlat};

        % Generate detections for each detector on this platform.
        [theseDets, ~, theseConfigs] = detect(thisPlatform, reflSigs, txConfigs, time);

        bufferDets = [bufferDets; theseDets]; %#ok<AGROW>

        % Collect configurations for each detector.
        rxConfigs = [rxConfigs; theseConfigs]; %#ok<AGROW>
    end

    % Reset detections after every scan of radar sensor.
    if txConfigs(end).IsScanDone
        plotDets = bufferDets;
    else
        plotDets = [plotDets;bufferDets]; %#ok<AGROW>
    end

    % Update display with current beam position, and detections.
    helperDisplay(reflSigs,plotDets,rxConfigs);
end
title('Radar detected by an ESM sensor');

Detections from the monostatic radar modeled using radarEmitter and radarSensor are shown as filled, blue circles near the target and the platform equipped with the ESM sensor. The ESM sensor is also able to detect the radar, as is indicated by the angle-only detection shown as a line originating from the ESM sensor and passing near the radar platform.

% Show the snapshot taken at 2 seconds into the simulation.
showGrabs(helperDisplay, 1);
title('Radar and target detected by an ESM sensor');

Because of the high power (EIRP) of the radar's emissions, the emitted energy is reflected off of the target towards the ESM platform as well. This results in the ESM sensor detecting the target platform at times when the radar emitter's field of view sweeps past the target platform when the target is still inside of the ESM sensor's field of view.

Summary

In this example, you learned how to simulate the impact of RF interference on a monostatic radar. You also learned how to simulate passive sensors which can detect these interference sources as well as the radar sensors in the scenario.

% Remove path to helper files used by this example.
delete(cleanPath);

Supporting Functions

commonRate

This function finds a common update rate across all of the sensor and emitter systems attached to platforms in the scenario. trackingScenario must be advanced at a fixed update rate. This function provides an update rate that is common to all of the systems modeled in the scenario, ensuring that each is called at a valid time interval.

function rate = commonRate(platforms)
dt = [];
for iPlat = 1:numel(platforms)
    thisPlatform = platforms{iPlat};
    theseSensors = thisPlatform.Sensors;
    for iSensor = 1:numel(theseSensors)
        thisSensor = theseSensors{iSensor};
        tau = round(1e6/thisSensor.UpdateRate); % microseconds
        if isempty(dt)
            dt = tau;
        else
            dt = gcd(dt,tau);
        end
    end
end
rate = 1e6./dt; % Hz
end