doppler estimation -凯发k8网页登录

radar system setup

first, we define a radar system. since the focus of this example is on doppler processing, we use the radar system built in the example . readers are encouraged to explore the details of through that example.

load basicmonostaticradarexampledata;

system simulation

targets

doppler processing exploits the doppler shift caused by the moving target. we now define three targets by specifying their positions, radar cross sections (rcs), and velocities.

tgtpos = [[1200; 1600; 0],[3543.63; 0; 0],[1600; 0; 1200]];
tgtvel = [[60; 80; 0],[0;0;0],[0; 100; 0]];
tgtmotion = phased.platform('initialposition',tgtpos,'velocity',tgtvel);
tgtrcs = [1.3 1.7 2.1];
fc = radiator.operatingfrequency;
target = phased.radartarget('meanrcs',tgtrcs,'operatingfrequency',fc);

note that the first and third targets are both located at a range of 2000 m and are both traveling at a speed of 100 m/s. the difference is that the first target is moving along the radial direction, while the third target is moving in the tangential direction. the second target is not moving.

environment

we also need to setup the propagation environment for each target. since we are using a monostatic radar, we use the two way propagation model.

fs = waveform.samplerate;
channel = phased.freespace(...
    'samplerate',fs,...
    'twowaypropagation',true,...
    'operatingfrequency',fc);

signal synthesis

with the radar system, the environment, and the targets defined, we can now simulate the received signal as echoes reflected from the targets. the simulated data is a data matrix with the fast time (time within each pulse) along each column and the slow time (time between pulses) along each row.

we need to set the seed for noise generation at the receiver so that we can reproduce the same results.

receiver.seedsource = 'property';
receiver.seed = 2009;
prf = waveform.prf;
num_pulse_int = 10;
fast_time_grid = unigrid(0,1/fs,1/prf,'[)');
slow_time_grid = (0:num_pulse_int-1)/prf;
% pre-allocate array for improved processing speed
rxpulses = zeros(numel(fast_time_grid),num_pulse_int);
for m = 1:num_pulse_int
    
    % update sensor and target positions
    [sensorpos,sensorvel] = sensormotion(1/prf);
    [tgtpos,tgtvel] = tgtmotion(1/prf);
    % calculate the target angles as seen by the sensor
    [tgtrng,tgtang] = rangeangle(tgtpos,sensorpos);
    
    % simulate propagation of pulse in direction of targets
    pulse = waveform();
    [txsig,txstatus] = transmitter(pulse);
    txsig = radiator(txsig,tgtang);
    txsig = channel(txsig,sensorpos,tgtpos,sensorvel,tgtvel);
    
    % reflect pulse off of targets
    tgtsig = target(txsig);
    
    % receive target returns at sensor
    rxsig = collector(tgtsig,tgtang);
    rxpulses(:,m) = receiver(rxsig,~(txstatus>0));
end

doppler estimation

range detection

to be able to estimate the doppler shift of the targets, we first need to locate the targets through range detection. because the doppler shift spreads the signal power into both i and q channels, we need to rely on the signal energy to do the detection. this means that we use noncoherent detection schemes.

the detection process is described in detail in the aforementioned example so we simply perform the necessary steps here to estimate the target ranges.

% calculate initial threshold
pfa = 1e-6;
% in loaded system, noise bandwidth is half of the sample rate
noise_bw = receiver.samplerate/2; 
npower = noisepow(noise_bw,...
    receiver.noisefigure,receiver.referencetemperature);
threshold = npower * db2pow(npwgnthresh(pfa,num_pulse_int,'noncoherent'));
% apply matched filter and update the threshold
matchingcoeff = getmatchedfilter(waveform);
matchedfilter = phased.matchedfilter(...
    'coefficients',matchingcoeff,...
    'gainoutputport',true);
[rxpulses, mfgain] = matchedfilter(rxpulses);
threshold = threshold * db2pow(mfgain);
% compensate the matched filter delay
matchingdelay = size(matchingcoeff,1)-1;
rxpulses = buffer(rxpulses(matchingdelay 1:end),size(rxpulses,1));
% apply time varying gain to compensate the range dependent loss
prop_speed = radiator.propagationspeed;
range_gates = prop_speed*fast_time_grid/2; 
lambda = prop_speed/fc;
tvg = phased.timevaryinggain(...
    'rangeloss',2*fspl(range_gates,lambda),...
    'referenceloss',2*fspl(prop_speed/(prf*2),lambda));
rxpulses = tvg(rxpulses);
% detect peaks from the integrated pulse
[~,range_detect] = findpeaks(pulsint(rxpulses,'noncoherent'),...
    'minpeakheight',sqrt(threshold));
range_estimates = round(range_gates(range_detect))

range_estimates = 1×2
        2000        3550

these estimates suggest the presence of targets in the range of 2000 m and 3550 m.

doppler spectrum

once we successfully estimated the ranges of the targets, we can then estimate the doppler information for each target.

doppler estimation is essentially a spectrum estimation process. therefore, the first step in doppler processing is to generate the doppler spectrum from the received signal.

the received signal after the matched filter is a matrix whose columns correspond to received pulses. unlike range estimation, doppler processing processes the data across the pulses (slow time), which is along the rows of the data matrix. since we are using 10 pulses, there are 10 samples available for doppler processing. because there is one sample from each pulse, the sampling frequency for the doppler samples is the pulse repetition frequency (prf).

as predicted by the fourier theory, the maximum unambiguous doppler shift a pulse radar system can detect is half of its prf. this also translates to the maximum unambiguous speed a radar system can detect. in addition, the number of pulses determines the resolution in the doppler spectrum, which determines the resolution of the speed estimates.

max_speed = dop2speed(prf/2,lambda)/2

max_speed = 224.6888

speed_res = 2*max_speed/num_pulse_int

speed_res = 44.9378

as shown in the calculation above, in this example, the maximum detectable speed is 225m/s, either approaching (-225) or departing ( 225). the resulting doppler resolution is about 45 m/s, which means that the two speeds must be at least 45 m/s apart to be separable in the doppler spectrum. to improve the ability to discriminate between different target speeds, more pulses are needed. however, the number of pulses available is also limited by the radial velocity of the target. since the doppler processing is limited to a given range, all pulses used in the processing have to be collected before the target moves from one range bin to the next.

because the number of doppler samples are in general limited, it is common to zero pad the sequence to interpolate the resulting spectrum. this will not improve the resolution of the resulting spectrum, but can improve the estimation of the locations of the peaks in the spectrum.

the doppler spectrum can be generated using a periodogram. we zero pad the slow time sequence to 256 points.

num_range_detected = numel(range_estimates);
[p1, f1] = periodogram(rxpulses(range_detect(1),:).',[],256,prf, ...
                'power','centered');
[p2, f2] = periodogram(rxpulses(range_detect(2),:).',[],256,prf, ...
                'power','centered');

the speed corresponding to each sample in the spectrum can then be calculated. note that we need to take into consideration of the round trip effect.

speed_vec = dop2speed(f1,lambda)/2;

doppler estimation

to estimate the doppler shift associated with each target, we need to find the locations of the peaks in each doppler spectrum. in this example, the targets are present at two different ranges, so the estimation process needs to be repeated for each range.

let's first plot the doppler spectrum corresponding to the range of 2000 meters.

periodogram(rxpulses(range_detect(1),:).',[],256,prf,'power','centered');

note that we are only interested in detecting the peaks, so the spectrum values themselves are not critical. from the plot of doppler spectrum, we notice that 5 db below the maximum peak is a good threshold. therefore, we use -5 as our threshold on the normalized doppler spectrum.

spectrum_data = p1/max(p1);
[~,dop_detect1] = findpeaks(pow2db(spectrum_data),'minpeakheight',-5);
sp1 = speed_vec(dop_detect1)

sp1 = 2×1
 -103.5675
    3.5108

the results show that there are two targets at the 2000 m range: one with a velocity of 3.5 m/s and the other with -104 m/s. the value -104 m/s can be easily associated with the first target, since the first target is departing at a radial velocity of 100 m/s, which, given the doppler resolution of this example, is very close to the estimated value. the value 3.5 m/s requires more explanation. since the third target is moving along the tangential direction, there is no velocity component in the radial direction. therefore, the radar cannot detect the doppler shift of the third target. the true radial velocity of the third target, hence, is 0 m/s and the estimate of 3.5 m/s is very close to the true value.

note that these two targets cannot be discerned using only range estimation because their range values are the same.

the same operations are then applied to the data corresponding to the range of 3550 meters.

periodogram(rxpulses(range_detect(2),:).',[],256,prf,'power','centered');

spectrum_data = p2/max(p2);
[~,dop_detect2] = findpeaks(pow2db(spectrum_data),'minpeakheight',-5);
sp2 = speed_vec(dop_detect2)

sp2 = 0

this result shows an estimated speed of 0 m/s, which matches the fact that the target at this range is not moving.

summary

this example showed a simple way to estimate the radial speed of moving targets using a pulse radar system. we generated the doppler spectrum from the received signal and estimated the peak locations from the spectrum. these peak locations correspond to the target's radial speed. the limitations of the doppler processing are also discussed in the example.