From Tim's website
Jump to: navigation, search

Pulse Compression

An efficient stepped-frequency pulse compression algorithm was required to process the radar data in real time. This was developed in Matlab and is summarized in a paper that was submitted as part of the project. The abstract for the paper is given below, with a link to an HTML version of the paper.

An algorithm is developed to increase the resolution of pulse radar using stepped-frequency linear chirps. 8 carriers are spaced at half the chirp bandwidth. This increases the resolution by a factor of 4. Phase corrections are made to the signals before they are combined. The required phase correction is found to be proportional to sampling time and carrier frequency. The correction can be made efficient if the sampling clock and carrier stepping oscillators are locked together. The algorithm is implemented in Matlab and demonstrated using real data. Targets include a single corner reflector and a series of three corner reflectors.

An Overview of the project

The Thales Radar is a versatile pulse radar used to measure targets under controlled conditions. This project is a tool to indicate the quality of the measurements being made with the radar in real time. The tool is written in C++ and runs in a Windows environment.

The information required from the tool is detailed in the Initial Requirements Specification. The tool must carry out the following steps to analyse the data:

  1. Load and decode the data either from a file or directly from the radar.
  2. Pulse compress the radar pulses (see the next section for details)
  3. Track a selected peak (typically a calibration plate)
  4. Produce figures indicating the variation in Range, Phase and Amplitude of the selected peak.

The data should also be displayed as a stack of down-range profiles. This can be useful as an experienced operator will quickly be able to spot problems with the raw data. It may also be possible to produce an ISAR image of the target under certain conditions, but this will be the last part of the project.

Some technical details

The software has been designed using an object orientated approach. The radar data stream can be separated into self contained blocks, each holding 4 pulses. The software contains a 'Received data' object which has a function to load from a given stream, and contains an array of 'Block' objects. When a stream is passed to the 'Received data' object it decodes the headers and stores them in the array of 'Blocks'. The headers are then analysed and the data for useful blocks is loaded. Functions are also provided to get the latest pulse and the number of blocks loaded etc.

The data for each block is stored in a 'Block' class, which is based on the MFC CObject class. This allows basic array operations to be performed directly on an array of 'Block' objects. Each 'Block' object contains an array of pulses, and each pulse is an array of complex float values. The 'Block' object also stores the header for the block as an array of bytes. Functions are then provided to get the time or pulse length etc. from the header. Some frequently accessed values are decoded from the header and stored as members of the 'Block' object for quick access. The functions used the header type to work out how to decode it at run time. In this way different header formats do not affect the rest of the program. Old header formats do not contain all the required information, and this is input by the user during the loop test calibration and then assumed to remain constant.

The pulse compression filter generated by the user from loop-back data, where the transmitted waveform is fed directly into the receiver. The 'Compression filter' object then holds the Fourier Transform of the averaged loop-back pulses. The filter may be loaded from received loop-back data stored a file.

Once the received blocks have been loaded, the 'Received data' returns to the function which gave it the data. This indicates that it has finished with the data and a new grab can commence. The 'Received data' object is then told to process the data, and compressed data is generated along with statistical information. (Range and phase jitter etc.) The 'Received data' object already contains the Compression filter, which performs the pulse compression. The first step is simply a convolution of the received data with the filter. This is done using FFT based convolution. If several pulses are loaded in a frequency agile sequence the compressed waveforms will be padded in the frequency domain and then coherently summed in the time domain. A fixed phase correction is required for the different path lengths of the different carriers, and a linear 'spiral' correction is also required for the range. This is described in my paper:

The time of the pulse is calculated from the header or from the pulse number. If the header time is not accurate enough, the block number is combined with the pulse repetition frequency to get a more accurate time. New block formats allow a higher clock resolution, and this is used where possible.

After the data blocks have been loaded and compressed, the 'Received data' object checks that the peak it was tracking in the last pulse is still the peak in the current pulse. If it is not, then it tracks the peak. The peak is found by quadratic interpolation of the highest point and its two neighbours. This allows the range of the peak to be found to a higher accuracy that the limit imposed by the bandwidth and sampling period.

Once all the processing has been completed the dialogs are informed that there is new data available. The down-range profile display scrolls up according to the time of the latest pulse, and prints the new pulse. The scrolling is achieved by shifting what is currently on the screen using 'bitblt' in a screen buffer, so if the dialog has just been made visible, it will still show the previous pulses. The pulse analysis dialog uses all the statistics stored in the 'Received data' object, as this is not a large amount of data to display in comparison with the down-range profiles.

On my 550MHz PIII the program processes about 40 pulses per second using simulated data grabbing from memory.

  • 5% Loading data
  • 6% Processing Windows messages and drawing plots
  • 89% Compressing the received signal:
    • 6% Conjugating arrays for the IFFT
    • 8% Moving data between arrays to create the full bandwidth spectrum
    • 75% In the Fast Fourier Transform function