Range Tracking

Range Tracking Estimation of the position of a moving target is generally referred to as “tracking”. Range Tracking is an extension to the independent measurement of range on a pulse by pulse or block (integrated) by block basis. It involves using the previous estimate of the range and range rate to predict the where the target will be in time for the next range measurement. Range gating Range gating process consists of sampling the received video signal at a specified time after the transmit pulse has been radiated. This involves measuring the amplitude of this signal over a short period using some form of electronic switch. The sample period should be about equal to the length of the transmitted pulse so that the maximum amount of pulse energy and the minimum amount of noise is incorporated into each sample. Principles of a Split-Gate Tracker A split gate tracker consists of two Sample and Hold circuits separated in time (range) by about one pulse width. They are known as the Early and Late gates. In early analog systems, these were in fact FET switches that allowed charge to flow into an integrator for the gate period as shown in the figure below.

Tracking The process applies simple estimation theory to predict where the target will be and by placing the gates at the correct range prior to the measurement taking place it improves the measurement accuracy. Placing the range gates as accurately as possible has two primary functions. In the first instance, it ensures that any residual errors are within the linear region of the range transfer function and are close to the true error. Secondly, by sampling the echo signal close to its peak ensures that the measurement SNR is as high as possible. Kalman filters and α-β trackers are widely used for track-while-scan and single target tracking applications. The α-β Filter The α-β tracker is a fixed gain formulation of the Kalman filter and is still widely used because it is easy to implement performs well in general. The α-β Tracker equations for range tracking are defined below Smoothing

𝑅̂𝑛 = 𝑅̂𝑝𝑛 + 𝛼(𝑅𝑛 − 𝑅̂𝑝𝑛 ) 𝑉̂𝑛 = 𝑉̂𝑝𝑛 +

𝛽 (𝑅 − 𝑅̂𝑝𝑛 ) 𝑇𝑠 𝑛

Prediction

𝑅̂𝑝(𝑛+1) = 𝑅̂𝑛 + 𝑉̂𝑛 . 𝑇𝑠 𝑉̂𝑝(𝑛+1) = 𝑉̂𝑛 where:

𝑅̂𝑛 = Smoothed Estimate of Range 𝑉̂𝑛 = Smoothed Estimate of Range Rate 𝑅𝑛 = Measured Range 𝑅̂𝑝(𝑛+1) = Predicted Range after T seconds 𝑉̂𝑝(𝑛+1) = Predicted Range after T seconds 𝑅̂𝑝𝑛 = Predicted Range at the Measurement Time

𝑉̂𝑝𝑛 = Predicted Velocity at the Measurement Time 𝑇𝑠 = Sample Time 𝛼, 𝛽 = Smoothing Constants

It has been suggested (Benedict and Bordner) that to minimize the output noise variance at steady state, and the transient response to a maneuvering target as modelled by a ramp function, then the gain coefficients are related as

𝛼2 𝛽= 2−𝛼 Other criteria can also be used. For example, it has been suggested that the filter should have the fastest possible step response (critical damping), in which case the coefficients are related as

𝛼 = 2√𝛽 − 𝛽 The actual values of the gains depend on the sample period, the predicted target dynamics and the required loop bandwidth. An α-β filter (with Benedict-Bordner gains) takes the error signal produced by the split gate tracker and produces estimates of the position and the rate. The one-sample ahead position estimate is fed back into the range gate timing circuitry to trigger the early and late gate samples. Range Tracking Systems Most range tracking systems are associated with angle trackers to produce a full 3D tracking capability. However, there are a number of applications in which the angular pointing function is either nonexistent or performed manually. Good examples of the latter are combined optical and ranging systems like close-in weapon systems or even some radar or lidar speed traps.

MATLAB Implementation

Range Tracking in the absence of RGPO

Range Tracking in the presence of RGPO

Code %% % In this experiment, three targets are located at different positions and % moving with different speeds. The tracking loop locks one target out of % three and track this target by using an Alpha-Beta Tracker %% target1 = phased.Platform([1200; 1600; 0],[6; 8; 0]); target2 = phased.Platform([3518.63; 0; 0],[140; 160; 0]); target3 = phased.Platform([3845.04; 0; 0],[100; 120; 150]); T = 0.5; Nsteps = 20; t = [1:Nsteps]*T;

R_est = zeros(1,Nsteps); R_prev = zeros(1,Nsteps); Rn= zeros(1,Nsteps); error = zeros(1,Nsteps); [tgtrng,tgtang_actual] = rangeangle(target1.InitialPosition,[0 0 0]'); range_initial = tgtrng+15; % add some sort of error R_prev(1)=range_initial; v0=10; % Initial speed V_prev=v0; X0=[range_initial v0 0].'; alpha=0.8; beta=alpha^2/(2-alpha); %beta=0.6; %alpha=2*sqrt(beta)-beta; RGPO_ON=1; % set it to 0 to turn off RGPO for n = 1:Nsteps [x1,y1] = step(target1,t(n)); [x2,y2] = step(target2,t(n)); [x3,y3] = step(target3,t(n)); plot(t(n),R_prev(n),'o') box on title('Range Predicted "o" vs Range Measured "x"') xlabel('time (sec)') ylabel('Range (Meters)') xlim([0 t(Nsteps)]) ylim([1950 3800]) pause(T); if n>19 RGPO_ON=0; end [Rn(n)] = range_measurement_RGPO(x1,y1,x2,y2,x3,y3,R_prev(n),t(n),RGPO_ON); error(n)=Rn(n)-R_prev(n); plot(t(n),Rn(n),'x') pause(T); [range_actual(n),tgtang_actual] = rangeangle(x1,[0,0,0].'); plot(t(n),range_actual(n),'.') %% Alpha-Beta Tracker %Smoothing R_sn(n)=R_prev(n)+(alpha*(error(n))); V_sn(n)=V_prev(n)+(beta*(error(n))/T); %Prediction R_est(n)=R_sn(n)+(V_sn(n)*T); V_est(n)=V_sn(n); % R_prev(n+1)= R_est(n); V_prev(n+1)=V_est(n); end

function [range_estimates] = range_measurement_RGPO(pos1,vel1,pos2,vel2,pos3,vel3,predicted_range,time,RGP O_ON) %% Radar Simulation %% %% Data Initialization %% pd = 0.9; % pfa = 1e-6; % max_range = 5000; % range_res = 50; % tgt_rcs = 1; %

Probability of detection Probability of false alarm Maximum unambiguous range Required range resolution Required target radar cross section

prop_speed = physconst('LightSpeed'); pulse_bw = prop_speed/(2*range_res); pulse_width = 1/pulse_bw; prf = prop_speed/(2*max_range); fs = 2*pulse_bw; hwav = phased.RectangularWaveform(... 'PulseWidth',1/pulse_bw,... 'PRF',prf,... 'SampleRate',fs);

% % % % %

Propagation speed Pulse bandwidth Pulse width Pulse repetition frequency Sampling rate

%% % *Receiver Noise Characteristics* noise_bw = pulse_bw; hrx = phased.ReceiverPreamp(... 'Gain',20,... 'NoiseFigure',0,... 'SampleRate',fs,... 'EnableInputPort',true); %% % % *Transmitter* snr_db = [-inf, 0, 3, 10, 13]; num_pulse_int = 10; snr_min = albersheim(pd, pfa, num_pulse_int); tx_gain = 20; fc = 10e9; lambda = prop_speed/fc; peak_power = radareqpow(lambda,max_range,snr_min,pulse_width,... 'RCS',tgt_rcs,'Gain',tx_gain); htx = phased.Transmitter(... 'Gain',tx_gain,... 'PeakPower',peak_power,... 'InUseOutputPort',true);

peak_power1 = radareqpow(lambda,0.5*max_range,snr_min,pulse_width,... 'RCS',tgt_rcs,'Gain',tx_gain); htx1 = phased.Transmitter(... 'Gain',tx_gain,... 'PeakPower',peak_power1,... 'InUseOutputPort',true); %% % *Radiator and Collector* % We assume that the antenna is stationary. hant = phased.IsotropicAntennaElement(... 'FrequencyRange',[5e9 15e9]); hantplatform = phased.Platform(... 'InitialPosition',[0; 0; 0],... 'Velocity',[0; 0; 0]); %% % With the antenna and the operating frequency, we define both the radiator % and the collector. hradiator = phased.Radiator(... 'Sensor',hant,... 'OperatingFrequency',fc); hradiator1 = phased.Radiator(... 'Sensor',hant,... 'OperatingFrequency',fc); hcollector = phased.Collector(... 'Sensor',hant,... 'OperatingFrequency',fc); %% System Simulation % *Targets* fc = hradiator.OperatingFrequency; fs = hwav.SampleRate; htarget{1} = phased.RadarTarget(... 'MeanRCS',1.3,... 'OperatingFrequency',fc); htargetplatform{1} = phased.Platform(... 'InitialPosition',pos1,... 'Velocity',vel1); htarget{2} = phased.RadarTarget(... 'MeanRCS',1.7,... 'OperatingFrequency',fc); htargetplatform{2} = phased.Platform(... 'InitialPosition',pos2,... 'Velocity',vel2); htarget{3} = phased.RadarTarget(... 'MeanRCS',2.1,...

'OperatingFrequency',fc); htargetplatform{3} = phased.Platform(... 'InitialPosition',pos3,... 'Velocity',vel3);

%% % *Environment* htargetchannel{1} = phased.FreeSpace(... 'SampleRate',fs,... 'TwoWayPropagation',true,... 'OperatingFrequency',fc); htargetchannel{2} = phased.FreeSpace(... 'SampleRate',fs,... 'TwoWayPropagation',true,... 'OperatingFrequency',fc); htargetchannel{3} = phased.FreeSpace(... 'SampleRate',fs,... 'TwoWayPropagation',true,... 'OperatingFrequency',fc); hspace1 = phased.FreeSpace(... 'SampleRate',fs,... 'TwoWayPropagation',false,... 'OperatingFrequency',fc); %% % *Signal Synthesis* hrx.SeedSource = 'Property'; hrx.Seed = 2009; prf = hwav.PRF; num_pulse_int = 10; fast_time_grid = unigrid(0,1/fs,1/prf,'[)'); slow_time_grid = (0:num_pulse_int-1)/prf; rx_pulses = zeros(numel(fast_time_grid),num_pulse_int); % pre-allocate

for m = 1:num_pulse_int [ant_pos,ant_vel] = step(hantplatform,1/prf); % update antenna position x = step(hwav); % obtain waveform x1=x; [s, tx_status] = step(htx,x); % transmit for n = 3:-1:1

% for each target

[tgt_pos(:,n),tgt_vel(:,n)] = step(... htargetplatform{n},1/prf); % update target position [tgt_rng(n), tgt_ang(:,n)] = rangeangle(...

tgt_pos(:,n), ant_pos); tsig(:,n) = step(hradiator,... s,tgt_ang(:,n)); tsig(:,n) = step(htargetchannel{n},... tsig(:,n),ant_pos,tgt_pos(:,n),... ant_vel,tgt_vel(:,n));

% calculate range/angle

rsig(:,n) = step(htarget{n},tsig(:,n));

% reflect

% radiate % propagate

end %% RGPO hwav1 = phased.RectangularWaveform(... 'PulseWidth',1/pulse_bw,... 'PRF',prf,... 'SampleRate',fs); x1 = step(hwav1);

% obtain waveform

Amplification=35; x1 = RGPO_ON*Amplification*delayseq(x1,41+fix(0.5*(time^2))); % delayed signal %41 corresponds to the initial range 2000 of the target1 [s1, tx_status1] = step(htx1,x1); % Transmitting the delayed signal [tgtrng1,tgtang1] = rangeangle(ant_pos,tgt_pos(:,1)); tsig1 = step(hradiator1,s1,tgtang1); % Radiating towards the Radar rsig(:,4)=step(hspace1,tsig1,tgt_pos(:,1),ant_pos,tgt_vel(:,1),ant_vel); %% rsig = step(hcollector,rsig,[tgt_ang tgt_ang(:,1)]); rx_pulses(:,m) = step(hrx,... rsig,~(tx_status>0)); % receive

% collect

end %% Doppler Estimation % *Range Detection* pfa = 1e-6; % in loaded system, noise bandwidth is half of the sample rate noise_bw = hrx.SampleRate/2; npower = noisepow(noise_bw,hrx.NoiseFigure,hrx.ReferenceTemperature); threshold = npower * db2pow(npwgnthresh(pfa,num_pulse_int,'noncoherent')); % apply matched filter and update the threshold matchingcoeff = getMatchedFilter(hwav); hmf = phased.MatchedFilter(... 'Coefficients',matchingcoeff,... 'GainOutputPort',true); [rx_pulses, mfgain] = step(hmf,rx_pulses); threshold = threshold * db2pow(mfgain); % compensate the matched filter delay

matchingdelay = size(matchingcoeff,1)-1; rx_pulses = buffer(rx_pulses(matchingdelay+1:end),size(rx_pulses,1)); % apply time varying gain to compensate the range dependent loss prop_speed = hradiator.PropagationSpeed; %% Split Range Gate %% range_gates = prop_speed*fast_time_grid/2; predicted_time=2*predicted_range/prop_speed; predicted_center=fix((predicted_time*fs)+1); sample_number=predicted_center; gate_size=5; early_late_gate_window=zeros(size(rx_pulses)); early_late_gate_window(sample_number-gate_size:sample_number+gate_size,:)=1; rx_pulses=early_late_gate_window.*rx_pulses; early_late_gate=zeros(size(range_gates)); early_late_gate(1,sample_number-gate_size:sample_number+gate_size)=1; early_late_gate=early_late_gate.*(prop_speed*fast_time_grid/2); range_gates=early_late_gate; %% %% lambda = prop_speed/fc; htvg = phased.TimeVaryingGain(... 'RangeLoss',2*fspl(range_gates,lambda),... 'ReferenceLoss',2*fspl(prop_speed/(prf*2),lambda)); rx_pulses = step(htvg,rx_pulses); RxSig=pulsint(rx_pulses,'noncoherent'); %% AGC %RCS_min=0.1; %for ultralight aircraft %RCS_max=100; %for big cargo plane %Rmin= prop_speed*(pulse_width+recovery_time)/2; % Pmin=(peak_power*(lambda^2)*tx_gain*RCS_min)/(max_range^4); % Pmax=(peak_power*(lambda^2)*tx_gain*RCS_max)/(Rmin^4); % Dynamic_Range=pow2db(Pmax/Pmin); % usually around 80 db N=length(RxSig); Pmax=(peak_power*(lambda^2)*tx_gain*100)/(150^4); %Rmin is taken as 150m % For accurate measurement of Rmin we need information of recovery time % Currently I have taken recovery time to be 1/2 of Pulsewidth % And this corresponds to blind range of 150m approximate_signal_power= (sum(RxSig(1:N,:).^2))/((2*gate_size)+1); if approximate_signal_power >= Pmax agc_gain=sqrt(Pmax/approximate_signal_power); RxSig=agc_gain*RxSig; end

%% % detect peaks from the integrated pulse

[~,range_detect] = findpeaks(RxSig,... 'MinPeakHeight',sqrt(threshold)); range_estimates = round(range_gates(range_detect)); TF = isempty(range_estimates); if TF==1 clc range_estimates=0; disp('******************************* **************') disp('******************************* **************') disp('******************************* **************') disp('************ No Signal Detected **************') disp('************ ****************** **************') disp('************ ****************** **************') disp('************ ****************** **************') end %% %{ % *Doppler Spectrum* max_speed = dop2speed(prf/2,lambda)/2; speed_res = 2*max_speed/num_pulse_int; num_range_detected = numel(range_estimates); for nr=1:num_range_detected [p(:,nr), f(:,nr)] = periodogram(rx_pulses(range_detect(nr),:).',[],256,prf, ... 'power','centered'); speed_vec = dop2speed(f(:,1),lambda)/2; %% % *Doppler Estimation* spectrum_data = p(:,nr)/max(p(:,nr)); [~,dop_detect1] = findpeaks(pow2db(spectrum_data),'MinPeakHeight',-5); sp(nr) = speed_vec(dop_detect1); end sp %} end