In [1]:

```
import math
# Variable Declaration
c = 3*10**8; # velocity of EM waves in m/s
f = 10*10**9; # carrier freq in Hz
fm = 100; # freq of modlating signal
dphi = 10; # separation b/w tx FM signal and demod echo signal in degrees
# Calculations
Tp = dphi/float((360*fm)); # round trip propagation time
R = (c*Tp)/float(2); # target range
# Result
print'Target Range = %3.2f Km'%(R/float(1000));
```

In [1]:

```
import math
# Variable Declaration
f = 10*10**9; # center freq. in Hz
f_us = 60*10**3; # upsweep freq. in Hz
f_ds = 80*10**3; # down sweep freq. in Hz
fm = 100; # modulation freq. in Hz
B = 2*10**6; # sweep bandwidth in Hz
c = 3*10**8; # vel. of EM waves in m/s
T = 5*10**-3;
# Calculations
fd = (f_ds - f_us)/float(2);
df = (f_ds + f_us)/float(2);
R = (c*T*df)/float((2*B)); # range in m
# fd = (2*Vr*f)/float(c);
Vr = (c*fd)/float((2*f)); # target radial velocity
Vr_kmph = Vr*(18/float(5)); # target radial velocity in kmph
Vr_nmph = Vr_kmph/float(1.85); # target radial velocity in Nautical miles per hour
#Result
print'Target Range = %3.2f Km\n'%(R/float(1000)),'Radial velocity = %3.1f Nmi/hr'%Vr_nmph;
```

In [2]:

```
import math
# Variable Declaration
Vr = 150
c = 3*10**8;
df1= 10**6;
# fd = (2*Vr)/lamda = (2*Vr*f)/c
# for 'Vr' and 'c' as constant(for a given radial velocity,Vr is constant)
# fd = K.f where 'f' is the operating frequency and K = (2*Vr)/c
# Therefore df = ± 1 Mhz around the center frequency
k = (2*Vr)/float(c);
df_d = df1*k
# Result
print'Doppler shift due to carrier frequency sweep = ±%d Hz'%df_d;
```

In [28]:

```
import math
# Variable Declaration
f = 10*10**9; # operating frequency in Hz
f_us = 100*10**3; # upsweep freq
f_ds = 100*10**3; # downsweep freq
Tus = 5*10**-3; # up-sweep period
Tds = 5*10**-3; # down-sweep period
T = 10*10**-3
B = 10*10**6; # sweep bandwidth
c = 3*10**8; # vel of EM waves in m/s
f_us_b = 80*10**3; # upsweep freq in fig b
f_ds_b = 50*10**3; # downsweep freq in fig b
f_us_c = 50*10**3; # upsweep freq in fig b
f_ds_c = 80*10**3; # downsweep freq in fig b
# Calculations
# a
fd = (f_us - f_ds)/float(2); # doppler shift
df = (f_us + f_ds)/float(2); # freq diff
Vr_a = (c*fd)/float((2*f)); # radial velocity
R = (c*Tus*df)/float((2*B)); # Range
if Vr_a == 0:
print'Case a:\nRadial velocity = %d'%Vr_a ,'\nRange = %3.3f Km\n'%(R/1000);
#b
fd = (f_us_b - f_ds_b)/2; # doppler shift
df_b = (f_us_b + f_ds_b)/2; # freq difference due to range
R_b = (c*T*df_b)/(2*B); # Range
Vr_b = (c*fd)/(2*f); # radial velocity
print'Case b:\nRadial velocity = %3.2fm/s'%Vr_b,'\n Range = %3.3f Km\n' %(R_b/1000);
print 'As the up-sweep frequency difference is less than downspeed freq diff, this implies that doppler shift is\ncontributing towards an increase in the echo signal freq. so, target is moving towards radar\n'
# c
fd = (f_us_c - f_ds_c)/2; # doppler shift
df_c = (f_us_c + f_ds_c)/2; # freq difference due to range
R_c = (c*T*df_c)/(2*B); # Range
Vr_c = (c*fd)/(2*f); # radial velocity
print'Case c:\n Radial velocity = %3.2fm/s' %abs(Vr_c),'\n Range = %3.3f Km\n' %(R_c/1000)
print' As the up-sweep frequency difference is greater than downspeed freq diff, this implies that doppler shift is\n contributing towards an decrease in the echo signal freq. so, target is moving away from radar';
```

In [9]:

```
import math
# Variable Declaration
f = 10*10**9; # operating freq in Hz
PRF = 1000; # pulse rep. rate
Vr = 1000; # radial velocity
c = 3*10**8; # vel. of EM waves in m/s
# Calculations
fd = (2*Vr*f)/c # true doppler shift
fA1 = abs(((fd%PRF) - PRF))%PRF
fA2 = abs(((fd%PRF) + PRF))%PRF
if fA1 < fA2:
fd = fA1; # apparent doppler shift
else:
fd = fA2; # apparent doppler shift
Vr = (c*fd)/(2*f); # radial velocity in m/s
# output
print'Radial velocity = %3.2f m/s' %Vr, '\n The radar measures the target to be moving away from the radial velocity at %3.2f m/s though in reality\n it is moving towards the radar with a velocity of 1000 m/s'%abs(Vr);
```

In [21]:

```
import math
# Variable Declaration
lamda = 3*10**-2; # Operating Wavelength in m
PRF = 2000; # pulse rep. freq in Hz
n = 1; # for lowest blind speed
# Calculations
LBS = ((n*lamda)/2)*PRF; # lowest blind speed
Vb_kmph = LBS*(18/float(5)) # lowest blind speed in kmph
# Result
print'Lowest Blind speed = %d Kmph' %Vb_kmph;
```

In [22]:

```
import math
# Given data
R = 100; # Range in kms
PRR = 10*10**3; # pulse rep. rate in Hz
c = 3*10**5; # vel. in km/s
# Calculations
PRI = 1/float(PRR); # pulse rep. interval
Ra = (R%(c*PRI/float(2))); # apparent range in km
# Output
print'Apparent Range = %d Km\n'%Ra;
```

In [9]:

```
import math
# Variable Declaration
Ra = 25; # Apparent Range in km
PRF = 2000; # Pulse rep. freq.
c = 3*10**5; # vel. of EM waves in km/s
Nr = 3; # Range zone
# Calculations
R = Ra + ((c/float(2))*((Nr - 1)/float(PRF))); # true range in km
# Result
print'True Range of the target = %d Km'%R;
```

In [30]:

```
import math
# Variable Declaration
PRF_1 = 750; # pulse rep. freq in Hz
PRF_2 = 1000; # pulse rep. freq in Hz
PRF_3 = 1250; # pulse rep. freq in Hz
Ra_1 = 100; # Apparent range for PRF_1
Ra_2 = 50; # Apparent range for PRF_2
Ra_3 = 20; # Apparent range for PRF_3
c = 3*10**5; # Vel of EM waves in Km/s
# Calculations
R12 =
for Nr in range(1,6):
R12 = Ra_1 + ((c/2)*((Nr - 1)/PRF_1)) # true range in km
R23 = Ra_2 + ((c/2)*((Nr - 1)/PRF_2)) # true range in km
R33 = Ra_3 + ((c/2)*((Nr - 1)/PRF_3)) # true range in km
# Output
print R12;
print'Possible True Range measurements for 750 PPS\n';
#print' = %dkm \n',R1;
print'Possible True Range measurements for 1000 PPS\n'
#print' = %dkm \n',R2;
print'Possible True Range measurements for 1250 PPS\n'
#print' = %dkm \n',R3;
#print'The shortest possible range that has been measured at all PRFs is %d Km True Range = %d km',R1(3),R1(3);
```

In [10]:

```
import math
# Variable Declaration
Te = 4 # Expanded pulse width in usec
f1 = 50 # RF freq in Mhz
f2 = 70 # RF freq in Mhz
# Calculations
B = f2 - f1; # Signal bandwidth
Tc = 1/float(B); # Compressed pulse width in us
CR = Te/float(Tc); # compression ratio
# Result
print'Compression Ratio = %d\n'%CR,'Width of compressed pulse = %3.2f us'%Tc;
```

In [32]:

```
import math
# Variable Declaration
f = 10*10**9; # operating freq in Hz
c = 3*10**8; # vel. of EM waves in m/s
Ae = 2; # Antenna aperture in m
R = 10*10**3; # Target Range in m
# Calculations
lamda = c/float(f); # Wavelength in m
bw3db = lamda/float(2); # 3dB beamwidth in radian
Leff = bw3db * R; # effective length
Xs = (R*lamda)/float((2*Leff)); # Cross range resolution
# Result
print'Effective Length = %d m'%Leff;
print'Cross range resolution = %d m'%Xs;
```

In [33]:

```
import math
# Variable Declaration
R = 6000; # Target Range
c = 3*10**8; # speed of light in m/s
# Calculations
t = (2*R)/float(c); # round trip time
# Result
print'Round Trip time = %d us'%(t/float(10**-6));
```

In [13]:

```
import math
# Variable declaration
v = 250; # velocity in m/s
lamda = 10.6*10**-6 # operating wavelength
theta = 60; # angle of depression
# Calculations
Vr = v*math.cos(theta*math.pi/float(180)); # radial velocity
fd = (2*Vr)/float(lamda); # doppler shift
# Result
print'Doppler Shift = %3.2f Mhz'%(fd*10**-6);
```

In [34]:

```
import math
# Variable Declaration
B = 10**6; # Bandwidth in Mhz
c = 3*10**8; # speed of light in m/s
# Calculations
RR = c/float((2*B)); # Range Resolution in m
# Result
print'Range Resolution = %d m\n'%RR;
```