In [1]:

```
import math
#Variable Declaration
Btr=36 #Transponder Bandwidth(MHz)
B=3 #Carrier Bandwidth(MHz)
EIRP=27 #saturated EIRP(dBW)
BO=6 #Back off loss(dB)
LOSSES=196 #Combined losses(dB)
GTR=30 #Earth station G/T ratio(dB)
k=228.6 #Value of k(dB)
#Calculation
Btr1=10*math.log10(Btr*10**6) #Converting transponder Bandwidth into decibels
B1=10*math.log10(B*10**6) #Converting carrier Bandwidth into decibels
CNR=EIRP+GTR-LOSSES+k-Btr1 #Carrier to noise ratio for single carrier operation(dB)
CNR=round(CNR)
alpha=-BO
K=alpha+Btr1-B1 #Fraction of Bandwidth actually occupied(dB)
K=10**(K/10) #Converting decibels to ratio
K=round(K)
#Results
print "The downlink carrier to noise ratio is",CNR,"dB"
print "Fraction of Bandwidth actually occupied is",K
print "No. of carriers that would be accommodated without backoff is",Btr/B
```

In [2]:

```
import math
#Variable decalration
N=40 #No.of bits
E=5 #Maximum number of errors allowed
p=10**-3 #Average probability of error in transmission
#Calculation
Pmiss=0
for i in range(E+1,N):
Pmiss=Pmiss+(math.factorial(N)/float((math.factorial(i)*math.factorial(N-i))))*(p**i)*((1-p)**(N-i))
Pmiss=Pmiss*10**12
Pmiss=round(Pmiss,1)
#Result
print "The probability of miss is",Pmiss,"*10^-12"
```

In [3]:

```
import math
#Variable decalration
N=40 #No.of bits
E=5 #Maximum number of errors allowed
#Calculation
Pfalse=0
for i in range(0,E+1):
Pfalse=Pfalse+(math.factorial(N)*2**-N)/float((math.factorial(i)*math.factorial(N-i)))
Pfalse=Pfalse*10**7
Pfalse=round(Pfalse,1)
#Result
print "The probability of miss is",Pfalse,"*10^-7"
```

In [4]:

```
#Variable ecalration
Lf=120832 #Total frame length
Tb=14 #Traffic burts per frame
Rb=2 #Reference bursts per frame
T=103 #Guard interval(symbols)
P=280 #Preamble Symbols
R=P+8 #Reference channel symbols with addition of CDC
#Calculation
OH=2*(T+R)+Tb*(T+P) #Overhead Symbols
nF=1-(OH/float(Lf)) #Frame Efficiency
nF=round(nF,3)
#Result
print "Hence the frame efficiency of INTELSAT frame is",nF
```

In [5]:

```
#Variable Declaration
Lf=120832 #Number of symbols per frame
Tf=2 #Frame period(ms)
nF=0.949 #INTELSAT fram efficiency from Example 14.4
#Calculation
Rs=(Lf/float(Tf))*10**-3 #Symbol rate(megasymbol/s)
Rt=Rs*2 #Transmission Rate
n=nF*Rt*10**3/64 #Voice channel capacity
n=round(n)
#Result
print " The voice channel capacity for the INTELSAT frame is",n,"Channels"
```

In [6]:

```
#Variable Declaration
CNR=87.3 #Downlink Carrier to noise ratio(dBHz)
BER=10**-5 #Bit Error Rate Required
R=0.2 #Roll off factor
EbN0R=9.5 #Eb/N0 ratio(dB)
#Calculation
Rb=CNR-EbN0R #Maximum Transmission Rate(dBb/s)
Rb1=10**(Rb/10) #Maximum Transmission Rate(b/s)
BIF=Rb1*1.2*10**-6/2 #IF Bandwith required
BIF=round(BIF,2)
#Result
print "The Maximum Transmission rate is",Rb,"dBb/s"
print "The IF bandwidth required is",BIF,"MHz"
```

In [7]:

```
#Variable Declaration
T1=1.544 #Bit rate from sec.10.4(Mb/s)
R=62 #Bit rate from sec.10.4(dBMb/s)
EbN0R=12 #Required Eb/N0 ratio for uplink(dB)
LOSSES=212 #Transmission losses of uplink(dB)
GTR=10 #G/T ratio for earth station(dB/K)
G1=46 #Uplink antenna gain(dB)
Rd=74 #Downlink Transmission Rate(dBb/s)
#Calculation
CNR=EbN0R+R #Carrier to noise ratio for uplink(dB)
EIRP=CNR-GTR+LOSSES-228.6 #EIRP of earth station antenna
P=EIRP-G1 #Transmitted Power Required(dBW)
P=10**(P/float(10)) #Transmitted Power Required(Watts)
P=round(P,2)
Ri=Rd-R #Rate increase with TDMA operation(dB)
P1=1.4+Ri #Uplink power increase required for TDMA operation(Watts)
P2=10**(P1/float(10))
P2=round(P2,1)
#Results
print "Earth station transmission power required for transmission of T1 baseband signal is",P,"Watts"
print "Uplink power increase required for TDMA operation is",P1,"dBWatts or",P2,"Watts"
```

In [8]:

```
import math
#Variable Declaration
BIF=36 #Bandwidth of channel over which carriers are spread(MHz)
R=0.4 #Rolloff factor for filtering
Rb=64 #Information bit rate(kb/s)
BER=10**-5 #Bit error rate required
EbN0R=9.6 #Eb/N0 ratio for BER given from Fig.10.18
#Calculation
Rch=BIF*10**6/(1+R) #Rate of unspreaded signal(chips/s)
Gp=Rch/(Rb*10**3) #Processing gain
Gp1=round(10*math.log10(Gp)) #Processing gain(dB)
EbN0R1=10**(EbN0R/float(10)) #Converting Eb/N0 into ratio
K=1+(1.4*Gp/EbN0R1) #Number of channels
K=math.floor(K)
#Result
print "The Processing Gain is",Gp1,"dB"
print "An estimate of maximum number of channels that can access the system is",K
```