Udacity, Sensor Fusion, Radar Target Generation and Detection
- Refer to
radar_target_generation_and_detection.m
- Frequency of operation = 77GHz
- Max Range = 200m
- Range Resolution = 1 m
- Max Velocity = 100 m/s
Max_Range_of_Radar = 200;
Max_Velocity_of_Radar = 100;
Range_Resolution_of_Radar = 1;
speed_of_light = 3e8;
- define the target's initial position and velocity.
- Note : Velocity remains contant
R = 110; % Target Initial Range
v = -20; % Target Velocity
-
Design the FMCW waveform by giving the specs of each of its parameters.
-
Calculate the Bandwidth (B), Chirp Time (Tchirp) and Slope (slope) of the FMCW chirp using the requirements above.
-
Operating carrier frequency of Radar
B = c/2*delta_r ; %Bandwidth of the sweep
Tchirp =5.5*2*range_max/c ; %Chirp Time
slope = B/Tchirp ; %slope of the FMCW chirp
- Operating carrier frequency of Radar
fc= 77e9; %carrier freq
- The number of chirps in one sequence.
- Its ideal to have
2^value
for the ease of running the FFT for Doppler Estimation.
Nd=128; % # of doppler cells OR # of sent periods % number of chirps
- The number of samples on each chirp.
Nr=1024; % for length of time OR # of range cells
- Timestamp for running the displacement scenario for every sample on each chirp
t=linspace(0,Nd*Tchirp,Nr*Nd); %total time for samples
- Creating the vectors for Tx, Rx and Mix based on the total samples input.
Tx=zeros(1,length(t)); %transmitted signal
Rx=zeros(1,length(t)); %received signal
Mix = zeros(1,length(t)); %beat signal
- Similar vectors for range_covered and time delay.
r_t=zeros(1,length(t)); % range_covered
td=zeros(1,length(t)); % time delay
- Signal generation and Moving Target simulation
- Running the radar scenario over the time
for i=1:length(t)
%For each time stamp update the Range of the Target for constant velocity.
r_t(i) = R + (v*t(i)); % Range at time instance i = initial range + velocity *time
td(i) = 2*r_t(i)/c; % trip time for the signal in radar signal processing
%For each time sample we need update the transmitted and
%received signal.
Tx(i) = cos(2*pi*(fc*t(i)+(0.5*slope*t(i)^2)));
Rx (i) = cos(2*pi*((fc*(t(i)-td(i)))+(0.5*slope*(t(i)-td(i))^2)));
%Now by mixing the Transmit and Receive generate the beat signal
%This is done by element wise matrix multiplication of Transmit and
%Receiver Signal
Mix(i) = Tx(i).*Rx(i);
end
- Reshape the vector into Nr*Nd array.
- Nr and Nd here would also define the size of Range and Doppler FFT respectively.
Mix = reshape(Mix,[Nr,Nd]);
- run the FFT on the beat signal along the range bins dimension (Nr) and normalise
sig_fft1 = fft(Mix,Nr);
sig_fft1 = sig_fft1./Nr;
- Take the absolute value of FFT output
sig_fft1 = abs(sig_fft1);
- Output of FFT is double sided signal, but we are interested in only one side of the spectrum.
- Hence we throw out half of the samples.
single_sig_y_fft1 = sig_fft1(1:Nr/2);
- Plotting the range
figure ('Name','Range from First FFT')
subplot(2,1,1)
- plot FFT output
plot(single_sig_y_fft1);
axis ([0 200 0 1]);
- Simulation Result
- The 2D FFT implementation is already provided here.
- This will run a 2DFFT on the mixed signal (beat signal) output and generate a range doppler map.
- You will implement CFAR on the generated RDM Range Doppler Map Generation.
- The output of the 2D FFT is an image that has reponse in the range and doppler FFT bins.
- So, it is important to convert the axis from bin sizes to range and doppler based on their Max values.
Mix = reshape(Mix,[Nr,Nd]);
- 2D FFT using the FFT size for both dimensions.
sig_fft2 = fft2(Mix,Nr,Nd);
- Taking just one side of signal from Range dimension.
sig_fft2 = sig_fft2(1:Nr/2,1:Nd);
sig_fft2 = fftshift (sig_fft2);
RDM = abs(sig_fft2);
RDM = 10*log10(RDM) ;
- Use the surf function to plot the output of 2DFFT and to show axis in both dimensions
doppler_axis = linspace(-100,100,Nd);
range_axis = linspace(-200,200,Nr/2)*((Nr/2)/400);
figure,surf(doppler_axis,range_axis,RDM);
- Simulation Result
- Slide Window through the complete Range Doppler Map
- Select the number of Training Cells in both the dimensions.
Tr = 10;
Td = 8;
- Select the number of Guard Cells in both dimensions around the Cell under test (CUT) for accurate estimation
Gr = 4;
Gd = 4;
- Offset the threshold by SNR value in dB
offset = 1.4;
- Create a vector to store noise_level for each iteration on training cells design a loop such that it slides the CUT across range doppler map by giving margins at the edges for Training and Guard Cells.
- For every iteration sum the signal level within all the training cells.
- To sum convert the value from logarithmic to linear using db2pow function.
- Average the summed values for all of the training cells used.
- After averaging convert it back to logarithimic using pow2db.
- Further add the offset to it to determine the threshold.
- Next, compare the signal under CUT with this threshold.
- If the CUT level > threshold assign % it a value of
1
, else equate it to0
. - Use
RDM[x,y]
as the matrix from the output of 2D FFT for implementing CFAR
RDM = RDM/max(max(RDM));
% CUT starts after training and Guard cells so starting the loop for sliding
% CUT from T+G+1
for i = Tr+Gr+1:(Nr/2)-(Gr+Tr)
for j = Td+Gd+1:Nd-(Gd+Td)
% Create a vector to store noise_level for each iteration on training cells
noise_level = zeros(1,1);
% Calculate sum of the noise signal level within all the training cells
%calculate sum of the signal level within all the training cells
for x = i-(Tr+Gr): i+(Tr+Gr)
for y= j-(Td+Gd): j+(Td+Gd)
if (abs(x-i)>Gr || abs(y-j)> Gd)
noise_level = noise_level + db2pow(RDM(x,y));
end
end
end
%Average the summed values for all of the training cells used.
noise_level = noise_level/(2*(Td+Gd+1)*2*(Tr+Gr+1)-(Gr*Gd)-1);
threshold = pow2db(noise_level);
threshold = threshold + offset;
CUT = RDM(i,j);
if (CUT > threshold)
RDM(i,j) = 1;
else
RDM(i,j) = 0;
end
end
end
- The process above will generate a thresholded block, which is smaller than the Range Doppler Map as the CUT cannot be located at the edges of matrix.
- Hence,few cells will not be thresholded.
- To keep the map size same set those values to 0.
RDM(union(1:(Tr+Gr),end-(Tr+Gr-1):end),:) = 0; % Rows
RDM(:,union(1:(Td+Gd),end-(Td+Gd-1):end)) = 0; % Columns
- Display the CFAR output using the Surf function like we did for Range
- Doppler Response output.
figure('Name','CA-CFAR Filtered RDM')
surf(doppler_axis,range_axis,RDM);
colorbar;
- Simulation Result