%EE 724 Fall 2019 Homework 8

%#ok<*UNRCH,*NBRAK,*DEFNU,*CLALL>
clear('all');
clc;
H=struct('Number',0);
%close('all');

save_figs = true;
prefix = 'ee724_hw_08';
BUDGE_IT = false;%plot budge style

%%%%%%%%%%%%%%%%%%
tern = @(varargin) varargin{3-logical(varargin{1})}();
saveas = @(varargin) tern(save_figs,@()saveas(varargin{:}),@()[]);
fixForFilename = @(s)strjoin(regexp(s,'[^-A-Za-z0-9]+','split'),'_');
makeFilename = @(varargin) fixForFilename(strjoin([{prefix};varargin(:)],'_'));

downsample = @(X,M) X(1:M:end);
rss = @(X) sqrt(sum(abs(X).^2));
%%%%%%%%%%%%%%%%%%


%%%%%%%%%%%%%%%%%%
fs_RF = 4e9;
fs_IF = 5e6;

tau_p = 100e-6;
Bt = 500e6;

tau_h = 102e-6;

R_res = rangeFromDelay(.1e-9);%resolution of stretch output
%%%%%%%%%%%%%%%%%%


TargetProto = @()struct('range',[],'range_rate',[]);
ProblemProto = @() ....
    struct('name',[],'tau_p',[],'Bt',[],'tau_h',[],...
    'tgt1',TargetProto(),'tgt2',TargetProto(),...
    'compensate',false);

part1t = ProblemProto();
part1t.name = 'Problem 1-Test. Range-Rate=0';
part1t.tau_p = 100e-6;
part1t.Bt = 500e6;
part1t.tau_h = 102e-6;
part1t.tgt1.range      = 0;
part1t.tgt1.range_rate = 0;
part1t.tgt2.range      = 0.75;
part1t.tgt2.range_rate = 0;

part1 = part1t;
part1.name = 'Problem 1. Range-Rate=-8000';
part1.tgt1.range_rate = -8000;
part1.tgt2.range_rate = -8000;

part2t = part1t;
part2t.name = 'Problem 2-Test. Range-Rate=0';
part2t.tau_p = 200e-6;
part2t.tau_h = 202e-6;

part2a = part2t;
part2a.name = 'Problem 2a. Range-Rate=-8000';
part2a.tgt1.range_rate = part1.tgt1.range_rate;
part2a.tgt2.range_rate = part1.tgt2.range_rate;

part2b = part2a;
part2b.name = 'Problem 2b. Range-Rate=-4000';
part2b.tgt1.range_rate = part2b.tgt1.range_rate/2;
part2b.tgt2.range_rate = part2b.tgt2.range_rate/2;

part3 = part1;
part3.name = 'Problem 3. Range-Rate=-200';
part3.tgt1.range_rate = -200;
part3.tgt2.range_rate = -200;

part5 = part1;
part5.name = 'Problem 5. Range-Rate=-8000 Compensated';
part5.compensate = true;

data = [part1t];
if BUDGE_IT
    data = data([]);
end
data(end+1) = part1;

if ~BUDGE_IT
    data(end+1) = part2t;
end
data = [data, [part2a,part2b,part3,part5]];

Ps1 = 1;
Ps2 = 0.5;

for i=1:length(data)
    problem = data(i);

    name  = problem.name;
    tau_p = problem.tau_p;
    Bt    = problem.Bt;
    tau_h = problem.tau_h;

    [Vo_f,v_return,range] = generateStretchProcessor(tau_p,Bt,tau_h,fs_RF,fs_IF,...
        R_res);

    R1  = problem.tgt1.range;
    Rd1 = problem.tgt1.range_rate;
    range_1 = @(t) (R1+Rd1*t);
    tgt1 = v_return(Ps1,range_1);

    R2  = problem.tgt2.range;
    Rd2 = problem.tgt2.range_rate;
    range_2 = @(t) (R2+Rd2*t);
    tgt2 = v_return(Ps2,range_2);

    vrx_1 = @(t)tgt1(t);
    vrx_2 = @(t)tgt1(t)+tgt2(t);

    if problem.compensate
        compensation = range_1;
    else
        compensation = [];
    end

    Vo1 = Vo_f(vrx_1,compensation);
    Vo2 = Vo_f(vrx_2,compensation);

    range_delay = delayFromRange(range);
    idx = (-15e-9<=range_delay & range_delay<=15e-9);
    H=figure(H.Number+1);clf;
    if ~BUDGE_IT
        hold('on');
    end
    plot(range_delay(idx)*1e9,abs(Vo1(idx)));
    h=xlabel('Range delay (ns)');h.FontSize=11;
    h=ylabel('|V_o(\tau)|');h.FontSize=11;
    grid('on');
    axis('tight');
    if BUDGE_IT
        h=title(['\bf' name ': Stretch Processor Output for One Target']);h.FontSize=12;
        saveas(H,makeFilename(name,'1_tgt'),'png');
    end

    if BUDGE_IT
        H=figure(H.Number+1);clf;
    end
    plot(range_delay(idx)*1e9,abs(Vo2(idx)));
    h=xlabel('Range delay (ns)');h.FontSize=11;
    h=ylabel('|V_o(\tau)|');h.FontSize=11;
    grid('on');
    axis('tight');
    if BUDGE_IT
        h=title(['\bf' name ': Stretch Processor Output for Two Targets']);h.FontSize=12;
        saveas(H,makeFilename(name,'2_tgt'),'png');
    end

    if ~BUDGE_IT
        legs = {'1 Target','2 Targets'};
        legend(legs,'Location','Best');
        h=title(['\bf' name ': Stretch Processor Outputs']);h.FontSize=12;
        saveas(H,makeFilename(name,'both_tgt'),'png');
    end

end

%%%%%%%%%%%%%%%%%%%%%%%%%
function [Vo_f,v_return,range] = generateStretchProcessor(tau_p,Bt,tau_h,fs_RF,fs_IF,R_res)
    tern = @(varargin) varargin{3-logical(varargin{1})}();
    if nargin<6 || isempty(R_res)
        %resolution of stretch output
        R_res = .015; %meters
    end
    tau_res = delayFromRange(R_res);

    Ts_RF = 1/fs_RF;
    Ts_IF = 1/fs_IF;

    %Transmit and return signal
    alpha = Bt/tau_p;
    v_tx = genLFM(tau_p,Bt);
    v_return = @(Ps,R) @(t)sqrt(Ps)*v_tx(t-delayFromRange(R(t)));

    % De-ramp system
    tau_m = 0;%assume tau_m = 0
    Bh = Bt*tau_h/tau_p; %larger bandwidth because it runs for longer
    h_s = genLFM(tau_h,Bh);
    h_s = @(t,R) h_s(t-tern(nargin<2 || isempty(R),@()0,@()delayFromRange(R(t))));

    % Implement the de-ramp mixer by forming vo(t) = r*(t)hs(t).
    mixer = @(r,t,R)conj(r(t)).*h_s(t,R);

    Nif = ceil(fs_IF/(alpha*tau_res));

    M_if_from_rf = ceil(fs_RF/fs_IF);

    ifFromRf = @(x) downsample(x,M_if_from_rf);

    Nrf = M_if_from_rf * Nif;

    tau = ([0:Nrf-1]-Nrf/2)*Ts_RF;
    T0 = max(tau(:))-min(tau(:)); %#ok<NASGU>

    k = 1/(tau_p);
    vo_rf = @(r,R) k*mixer(r,tau,R);
    vo_if = @(r,R) ifFromRf(vo_rf(r,R));

    % 6. Process the down-sampled signal through the FFT. This generates Vo(f).
    % Don’t forget the fftshift to center the FFT output at f = 0.
    % Scale the FFT output by [τp/(0.25*10−9)]/(4000/5) to normalize
    % the peak to 1.0 when you use the r(t) with the single pulse centered
    % at R = 0. The term in brackets is the number of samples of vo(t)
    % into the ADC and the overall expression is the number of samples in
    % vo(t) after the ADC.
    Vo0 = Ts_IF;
    Vo_f = @(r,R) fftshift(fft(vo_if(r,tern(nargin<2,@()[],@()R))))*Vo0;

    f = fs_IF/2*linspace(-1,1,Nif);
    range_delay = tau_m+f/alpha;
    range = rangeFromDelay(range_delay);
end
%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%
function [X]= rect(t,T)
    %Simple window function centered at 0, with width T, and height 1
    T = T/2;
    t = abs(t/T);
    X = 1.*(-1<=t & t<=+1);
end

function [f] = genLFM(T,B,w)
   %generates an LFM function that is centered at 0
   % with width T
   % bandwidth B
   % and windowed by w
   if nargin<3
       w = @rect;
   end
   a = B/T;
   f = @(t) exp(1j*pi*a*t.^2).*w(t,T);
end

function [h] = genMatchedFilter(v)
    %generates the matched filter function given function v
    h = @(t) conj(v(-t));
end

function [tau] = delayFromRange(R)
    SPEED_OF_LIGHT = 3e8;
    tau = 2*R/SPEED_OF_LIGHT;
end

function [R] = rangeFromDelay(tau)
    SPEED_OF_LIGHT = 3e8;
    R = SPEED_OF_LIGHT/2*tau;
end
%%%%%%%%%%%%%%%%%%