Radar Design from Radar Equation to RF Components

Radar Equation Analysis With Radar Designer App

In the first part of this example, we use the Radar Designer app to derive some key operating parameters for the radar being modelled. We start with the following system level requirements:

With these system level requirements in hand, the Radar Designer app is used to derive the following operating parameters:

To do so, we enter the system level requirements defined above, and adjust the derived operating parameters until all requirements are met. The image below shows the final state of the Radar Designer app. We highlight the starting parameters (blue) and the derived parameters (yellow).

The following are the values derived for each of our operating parameters of interest:

For more information on using the Radar Designer app, see Radar Link Budget Analysis (Radar Toolbox).

Signal Level Simulation with System Level Components

After using the Radar Designer app to derive operating parameters from system level requirements using the radar equation, we use Simulink to create a radar model to confirm that we can detect targets at the maximum specified range with the operating parameters that were derived using the Radar Designer app. The radar model is made up of the following Simulink blocks. These blocks are set up so that they operate with the parameters derived in the previous section.

A MATLAB script containing the parameters derived in the previous section can be exported from the Radar Designer app which could make it easier to paramaterize the Simulink blocks. For the sake of this example, the derived values are stored in a helper function and loaded by the Simulink model. The radar model with the blocks described above is shown below:

open_system('slexSystemLevelRadarModel')

In this model, the Linear FM Waveform, the Receiver, the Matched Filter, and the Pulse Integrator can be directly set up using the specified operating parameters. Some additional analysis is required to set up the Transmitter to have the correct output power and to set up the Narrowband Transmit/Receive Arrays to have the correct antenna gain, as these operating parameters do not map directly to a property on those blocks.

The transmitter is assumed to operate in saturation to maximize the efficiency, which is common for many radar transmitters. We use a cubic polynomial gain model to simulate the non-linearity of the transmitter. From the radar equation level analysis, the transmitter output power must be >100 W. The linear gain and output third order intercept point (OIP3) are set in the simulation to meet this output power requirement. The figure below shows the output power as a function of input power for the given Transmitter configuration.

helperPlotTransmitterOutputPower();

From the plot of the transmitter output power, we can see that the power requirement is met when the transmitter operates in saturation. The linear gain, OIP3, and peak input power used to generate this figure are referenced in the Simulink Transmitter block to generate an output power of ~100 W.

The antenna array in this example is required to provide 20 dBi of gain. We use a 6x6 URA with a directional gain from a phased.CosineAntennaElements in order to achieve this desired antenna gain. The following figure shows that the array defined above meets the requirements derived for antenna gain.

helperPlotAntennaGain();

From the plot of antenna gain, we can see that the gain requirement is met with the given array. The array definition is referenced in the Simulink Narrowband Transmit and Receive array blocks. Only the Transmit Array dialog is shown below because the dialogs for these two blocks are effectively the same.

For this simulation, we set up two targets - one target at 1 km and one at the maximum range requirement (4 km). We run the simulation and visualize the detections of these targets using a Constant False Alarm Rate (CFAR) algorithm with the required probability of false alarm.

rng("default");
sim('slexSystemLevelRadarModel');

This figure shows that we successfully detect targets as expected using a model made up of system level components. This confirms the accuracy of the initial analysis that was performed using the Radar Designer app.

Transmitter and Receiver Friis Equation Analysis with RF Budget Analyzer App

The goal of this section is to further elaborate on the radar design, by replacing the high level Transmitter and Receiver models with an architecture containing individual RF components:

We achieve this by using the RF Budget Analyzer app to build a cascade of RF components that meets the transmitter saturation power and receiver noise figure used in the previous simulation according to the Friis equations.

In this example, the Transmitter and Receiver share a common path RF chain that includes an amplifier, a phase shifter, and an attenuator. Two switches are used in the Transmit and Receive path so that the common path can be shared. In this model, ideal behavior is assumed for many of the components for simplicity.

The transmitter is made of the common path chain, plus a driver amplifier and a power amplifier (PA). To correspond to the transmitter model used in the previous section, the transmit chain built in this section must have a total gain of 50 dB and a total OIP3 of 60 dBm. Using the RF Budget Analyzer app, we build a transmit chain with those desired characteristics (see the values highlighted in green).

The receiver is made of a low-noise amplifier (LNA), a stage amplifier, followed by the common path chain. To correspond to the receiver model used in the previous section, the receive chain built in this section must have a total noise figure of 3 dB. Using the RF Budget Analyzer app, we build a receive chain with that desired characteristic (see the value highlighted in green).

In the following section, we replace the transmitter and receiver models with the transmit and receive chains created in this section and verify that the targets are still detected using the higher fidelity model. The RF Budget Analyzer app provides an option for exporting RF chains to Simulink, which could be used as a way to partially automate the setup of the model in the next section. For more information on using the RF Budget Analyzer app, see RF Budget Analyzer (RF Toolbox).

Signal Level Simulation with RF Chain Level Components

The static RF budget analysis of the Transmit Receive Module (TRM) performed at the power-level in the previous section provides the basis for developing an architectural model for further simulation. In this section, we replace the transmitter and receiver with individual RF Components from the Idealized Baseband Library.

In the higher fidelity Simulink model, the Transmitter and Receiver blocks are replaced with a Multi-Channel Transmit Receive Module (TRM) subsystem.

open_system('slexComponentLevelRadarModel')

This subsystem iterates over the following Transmit-Receive Module for each antenna channel. The Idealized Baseband Library blocks used in this model correspond to the elements defined in the RF Budget Analyzer app.

open_system('slexComponentLevelRadarModel/Multi-Channel TRM/Channel Iterator/Single-Channel TRM')

We run the simulation and visualize the detections using a Constant False Alarm Rate (CFAR) algorithm with the required probability of false alarm.

rng("default");
sim('slexComponentLevelRadarModel');

There are no notable differences between this figure and the figure generated using the high-level Transmitter and Receiver models. This figure shows that we still successfully detect the targets when we replace the Transmitter and Receiver blocks with a more detailed model using Idealized Baseband blocks.

Summary

In this example we model a radar at increasing levels of fidelity, from the radar equation using the Radar Designer app to a model utilizing individual RF components. Using this systematic approach, we develop a radar model that is not only aligned with our initial requirements but also gains in realism and predictive capability.

Helper Functions

function helperPlotTransmitterOutputPower()
    % Load the example operating parameters
    params = helperSlexSystemParameters;

    % Plot the Transmitter output power curve
    transmitter = phased.Transmitter(GainMethod="Cubic polynomial",Gain=params.transmitGain,OIP3=params.transmitOip3);

    % Plot the gain curve
    ax = axes(figure); legend(ax,Location="southeast");
    transmitter.viewGain(Parent=ax);
    ax.Children.DisplayName = 'Output Power';

    % Overlay the required peak output power
    pTransmitDbm = pow2db(params.pTransmit*1e3);
    yline(ax,pTransmitDbm,DisplayName="Required Transmit Power",LineStyle="--",LineWidth=2);
end

function helperPlotAntennaGain()
    % Load the example operating parameters
    params = helperSlexSystemParameters;

    % Create element
    element = phased.CosineAntennaElement(FrequencyRange=params.fElement,CosinePower=params.cosPowExp);

    % Create array
    array = phased.URA(params.nElements,params.elementSpacing,Element=element);

    % Plot pattern
    ax = axes(figure);
    pattern(array,params.fc,-30:30,0,CoordinateSystem='rectangular',Type='directivity',Parent=ax);
    ax.Children.DisplayName = 'Antenna Directivity'; legend(ax,Location="southeast");
    yline(ax,params.antennaGain,DisplayName="Required Array Gain",LineStyle="--",LineWidth=2);
end