diff options
| author | Thomas Stephen Lee | 2015-09-07 17:46:06 +0530 |
|---|---|---|
| committer | Thomas Stephen Lee | 2015-09-07 17:46:06 +0530 |
| commit | 78784b374b2d1a9be66eb4ad41470409e2bd4dfa (patch) | |
| tree | 7b0144248a9d5c9b6c66065697177ee04a30f93e /Wireless_Communications_and_Networking_by_V._Garg | |
| parent | 41f1f72e9502f5c3de6ca16b303803dfcf1df594 (diff) | |
| download | Python-Textbook-Companions-78784b374b2d1a9be66eb4ad41470409e2bd4dfa.tar.gz Python-Textbook-Companions-78784b374b2d1a9be66eb4ad41470409e2bd4dfa.tar.bz2 Python-Textbook-Companions-78784b374b2d1a9be66eb4ad41470409e2bd4dfa.zip | |
add/update books
Diffstat (limited to 'Wireless_Communications_and_Networking_by_V._Garg')
18 files changed, 5404 insertions, 0 deletions
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb new file mode 100755 index 00000000..b47575f1 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb @@ -0,0 +1,331 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:52a8123efdb6330b1c01d828fbdcc37a6411e5ce1469de2c94b22a16e7b4d8c8" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 10: Antennas, Diversity and Link Analysis" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.1, Page 292" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "D=10000; #in metres\n", + "TxEIRP=30; #Effective Isotropic Radiated Power(EIRP)dBW\n", + "lamda=0.2; #in metres\n", + "Pt=10; #Transmitted power in dBW\n", + "Gt=20; #transmitter gain in dBi\n", + "Gr=3; #receiver gain in dBi\n", + "Lo=6;#total system lossses in dB\n", + "Nf=5; #noise figure in dB\n", + "BW=1.25; #mHz\n", + "k=1.38*10**-23; #Boltzmann constant\n", + "T=290; #temperature in degree kelvin\n", + "\n", + "#Calculations\n", + "Lp=20*math.log10(lamda/(4*math.pi*D)); #free space loss\n", + "Pr=Lp+Pt+Gt+Gr-Lo;# received power in dBW\n", + "No=10*math.log10(k*T); #Noise density in dBW\n", + "NO=No+30; #factor of '30' to convert from dBW to dBm\n", + "Pn=Nf+10*math.log10(BW*10**6)+NO;# noise signal power in dBm\n", + "SNR=(Pr+30)-Pn;\n", + "\n", + "#Results\n", + "print 'The received signal power is %d dBm'%(round(Pr+30)); #factor of '30' to convert from dBW to dBm\n", + "print 'SNR is %d dB'%SNR" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The received signal power is -59 dBm\n", + "SNR is 49 dB\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.2, Page 293" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "#As we have to use data from Eg 10.1, \n", + "D=10000; # in metres\n", + "TxEIRP=30; #Effective Isotropic Radiated Power(EIRP)dBW\n", + "lamda=0.2; #in metres\n", + "Pt=10; #trasmitted power in dBW\n", + "Gt=20; #transmitter gain in dBi\n", + "Gr=3; #receiver gain in dBi\n", + "Lo=6;#total system lossses in dB\n", + "Nf=5; #noise figure in dB\n", + "BW=1.25; #mHz\n", + "k=1.38*10**-23; #Boltzmann constant\n", + "T=290; #temperature in degree kelvin\n", + "#additional data given in this eg\n", + "hr=40.; #height of receiver in metre\n", + "ht=2; #trasmittter antenna height in metres\n", + "\n", + "#Calculations\n", + "Lp=20*math.log10(hr*ht/D**2);\n", + "Pr=Lp+Pt+Gt+Gr-Lo;# received power in dBW\n", + "No=10*math.log10(k*T); #Noise density in dBW\n", + "NO=No+30; #factor of '30' to convert from dBW to dBm\n", + "Pn=Nf+10*math.log10(BW*10**6)+NO;# noise signal power in dBm\n", + "SNR=(Pr+30)-Pn;\n", + "\n", + "#Result\n", + "print 'The received signal power is %d dBm'%(round(Pr+30)); #factor of '30' to convert from dBW to dBm\n", + "print 'SNR is %d dB'%SNR" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The received signal power is -65 dBm\n", + "SNR is 43 dB\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.3, Page 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Pin=12.; #Input power in watts\n", + "Ploss=3; #resistive losses in Watts\n", + "D=5; #Directivity\n", + "\n", + "#Calculations\n", + "Eff=(Pin-Ploss)/Pin;\n", + "G=Eff*D;\n", + "\n", + "#Results\n", + "print 'Gain of the antenna is %.2f dB = %.2f'%(10*math.log10(G),G);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Gain of the antenna is 5.74 dB = 3.75\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.4, Page 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "G=12.; #Gain of antenna in dBi\n", + "\n", + "#Calculations\n", + "Theta=101.5/10**(G/10);\n", + "\n", + "#Result\n", + "print 'The 3-dB beam width of a linear element antenna is %.1f degrees'%Theta" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The 3-dB beam width of a linear element antenna is 6.4 degrees\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.5, Page 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "N=12; #number of turns\n", + "fr=1.8; #frequency in GHz\n", + "\n", + "#Calculations\n", + "lamda=3*10**8/(fr*10**9);\n", + "DH=lamda/math.pi;# diameter of helix in milli-meters\n", + "S=lamda/4;#turn spacing in millimetres\n", + "L=N*S;\n", + "G=15*N*S*(DH*math.pi)**2/lamda**3;\n", + "Theta=52*lamda/(math.pi*DH)*math.sqrt(lamda/(N*S));\n", + "\n", + "#Results\n", + "print 'The optimim diameter is %d mm'%(DH*1000);\n", + "print 'Spacing is %.1f mm'%(S*1000);\n", + "print 'Total Length of antenna is %d mm'%(L*1000);\n", + "print 'The antenna gain is %.1f dBi'%(10*math.log10(G));\n", + "print 'The BeamWidth of antenna is %d degrees'%Theta" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The optimim diameter is 53 mm\n", + "Spacing is 41.7 mm\n", + "Total Length of antenna is 500 mm\n", + "The antenna gain is 16.5 dBi\n", + "The BeamWidth of antenna is 30 degrees\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.6, Page 305" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "E0=1000.; #average SNR\n", + "Eg=10; #threshold value for SNR\n", + "M=3; #3-Branch Combiner\n", + "e=2.71828; #Euler's number\n", + "\n", + "#Calculations&Results\n", + "x=Eg/E0;\n", + "P3=(1-e**(-x))**M; #Considering 3-branch selection combiner\n", + "print 'By considering 3-branch selection combiner technique, probability comes to be %.e'%P3;\n", + "P1=(1-e**(-x));#M=1;\n", + "print ' BY not considering diversity technique, probability comes to be %.e'%P1;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "By considering 3-branch selection combiner technique, probability comes to be 1e-06\n", + " BY not considering diversity technique, probability comes to be 1e-02\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10.7, Page 312" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "SR=3.84; #spreading rate in Mcps\n", + "\n", + "#Calculations\n", + "ChipDur=1./(SR*10**6);\n", + "Speed=3*10**8;\n", + "Dd=ChipDur*Speed;\n", + "\n", + "#Result\n", + "print 'Minimum delay distance to successfully resolve the multipath components and operate the Rake receiver is %d m'%Dd" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum delay distance to successfully resolve the multipath components and operate the Rake receiver is 78 m\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb new file mode 100755 index 00000000..9cc0698a --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb @@ -0,0 +1,469 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:a9273e79f8d5c3c028c517c94bebc1e2c1c9a292aef113298724eb86d1685f66" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 11: Spread Spectrum (SS) and CDMA Systems" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.1, Page 322" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "CR1=1.2288; #Mcps(Clock rate 1)\n", + "CR2=5.;#Mcps(Clock rate 2)\n", + "R1=9.6; #Information rate in Kbps for CR1\n", + "PG2=256; #Processing Gain for CR2\n", + "\n", + "#Calculations\n", + "PG1=10*math.log10(CR1*10**3/9.6);#Processing Gain for CR1\n", + "R2=CR2*10**3/PG2;#information rate in Kbps for CR2\n", + "\n", + "#Results\n", + "print 'The processing gain for clock rate 1.2288Mcps is %d dB'%PG1\n", + "print 'Improvemrnt in information rate is %.2f Kbps'%(R2-R1);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The processing gain for clock rate 1.2288Mcps is 21 dB\n", + "Improvemrnt in information rate is 9.93 Kbps\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.2, Page 326" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "#From figure 11.5 we get resultant demodulated signal at a mobile;\n", + "Rx=[[1,1,1,1,-3,1],[1,-3,1,1,1,1],[1,-3,1,1,1,-3],[1,-3,1,1,1,1],[-1,3,3,-1,3,-1]];#Resultant demodulated signal at mobile\n", + "\n", + "#from Figure 11.4 \n", + "c1=[[-1,-1,-1,-1,1,1],[1,-1,1,1,-1,-1],[1,-1,1,-1,-1,-1],[-1,1,1,1,-1,1],[1,-1,-1,1,-1,1]];\n", + "c2=[[1,1,-1,1,1,-1],[-1,1,-1,1,-1,-1],[-1,-1,1,1,1,-1],[1,1,-1,-1,1,-1],[1,-1,-1,-1,-1,-1]];\n", + "c3=[[-1,-1,1,-1,1,-1],[-1,-1,-1,1,1,1],[-1,1,1,-1,-1,1],[-1,1,-1,-1,-1,-1],[1,1,1,-1,1,1]];\n", + "\n", + "#Calculations&Results\n", + "#t={[1 2 3 4 5 6];[7 8 9 10 11 12];[13 14 15 16 17 18];[19 20 21 22 23 24];[25 26 27 28 29 30]};\n", + "#for Mobile 1\n", + "for i in range(0,5):\n", + " Demod1=c1[i][0]*Rx[i][0]+c1[i][1]*Rx[i][1]+c1[i][2]*Rx[i][2]+c1[i][3]*Rx[i][3]+c1[i][4]*Rx[i][4]-1\n", + " if(Demod1<0):\n", + " B1=1;\n", + " else:\n", + " B1=0;\n", + "\n", + "#for mobile 2\n", + "for i in range(0,5):\n", + " Demod2=c2[i][0]*Rx[i][0]+c2[i][1]*Rx[i][1]+c2[i][2]*Rx[i][2]+c2[i][3]*Rx[i][3]+c2[i][4]*Rx[i][4]+1;\n", + " if(Demod2<0):\n", + " B2=1;\n", + " else:\n", + " B2=0;\n", + "\n", + "#for mobile 3\n", + "for i in range(0,5):\n", + " Demod3=c3[i][0]*Rx[i][0]+c3[i][1]*Rx[i][1]+c3[i][2]*Rx[i][2]+c3[i][3]*Rx[i][3]+c3[i][4]*Rx[i][4]-1;\n", + " if(Demod3<0):\n", + " B3=1;\n", + " else:\n", + " B3=0;\n", + "\n", + "print \"Value of integration at end of bit period for mobile1\",Demod1\n", + "print \"Value of integration at end of bit period for mobile2\",Demod2\n", + "print \"Value of integration at end of bit period for mobile3\",Demod3\n", + "print \"The recovered signal at mobile 1 is \",B1\n", + "print \"The recovered signal at mobile 2 is \",B2\n", + "print \"The recovered signal at mobile 3 is \",B3\n", + "print \"In all cases, Recovered signal is negated value of transmitted signal\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of integration at end of bit period for mobile1 -12\n", + "Value of integration at end of bit period for mobile2 -8\n", + "Value of integration at end of bit period for mobile3 8\n", + "The recovered signal at mobile 1 is 1\n", + "The recovered signal at mobile 2 is 1\n", + "The recovered signal at mobile 3 is 0\n", + "In all cases, Recovered signal is negated value of transmitted signal\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.3, Page 332" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "BW=100; #in MHz\n", + "Fspac=10; #frequency spacing in kHz\n", + "\n", + "#Calculations\n", + "FreqTones=BW*10**3/Fspac;\n", + "Chips=math.log(FreqTones,2);\n", + "\n", + "#Result\n", + "print 'Minimum number of chips required are %d chips'%Chips" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum number of chips required are 13 chips\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.4, Page 332" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "R=120; #transmission rate in kbps\n", + "Hop=2000; #per second\n", + "Spectrum=10; #in MHz\n", + "\n", + "#Calculations&Results\n", + "#For 32-FSK\n", + "Bits_sym=math.log(32,2);\n", + "SR=R/Bits_sym;\n", + "print 'Bits per symbol are %d'%Bits_sym\n", + "print 'Hops per second are 2000 and Symbol rate is %d kbps'%SR\n", + "Sym_hop=SR*10**3/Hop;\n", + "Min_BW=Sym_hop*SR;\n", + "Nonoverlap_hop=Spectrum*10**3/Min_BW;\n", + "print 'Symbols transmitted per hop are %d'%Sym_hop;\n", + "print 'Number of non-Overlapping hop frequencies are %d'%(round(Nonoverlap_hop))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Bits per symbol are 5\n", + "Hops per second are 2000 and Symbol rate is 24 kbps\n", + "Symbols transmitted per hop are 12\n", + "Number of non-Overlapping hop frequencies are 35\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.5, Page 332" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "R=200;#input data rate in bps\n", + "Fhop=200;#per second\n", + "k=1;#Multipication_Factor\n", + "\n", + "#Calculations&Results\n", + "# We have 32-FSK modulation scheme\n", + "Bits_sym=math.log(32,2);\n", + "Rs=Fhop/Bits_sym;\n", + "print 'There are 200 hops per second and Symbol rate is %d symbols per sec'%Rs; \n", + "\n", + "SDur=1/Rs;\n", + "L=Fhop/Rs;\n", + "CDur=SDur/L;\n", + "Separation=1/CDur;\n", + "M=2**Bits_sym;\n", + "Hop_BW=k*M*Fhop*L;\n", + "Gp=M*k*L; \n", + "\n", + "\n", + "print ' Minimum separation between frequency tones should be %d Hz'%Separation;\n", + "print ' Number of different frequency tones produced by a frequency synthesizer are %d'%M;\n", + "print ' Processing Gain is %d'%Gp;\n", + "print 'Hopping bandwidth is %d kHz'%(Hop_BW/1000);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "There are 200 hops per second and Symbol rate is 40 symbols per sec\n", + " Minimum separation between frequency tones should be 200 Hz\n", + " Number of different frequency tones produced by a frequency synthesizer are 32\n", + " Processing Gain is 160\n", + "Hopping bandwidth is 32 kHz\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.6, Page 342" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "M1=[1,0,0,1,1];\n", + "\n", + "Rx1=[[1,1,1,1,-3,1],[1,-3,1,1,1,1],[1,-3,1,1,1,-3],[1,-3,1,1,1,1],[-1,3,3,-1,3,-1],[1,-1,-1,0,0,0]];#Resultant demodulated signal at mobile(Z(t)) from path1\n", + "Rx2=[[-1,-1,1,1,1,1],[-3,1,1,-3,1,1],[1,1,1,-3,1,1],[1,-3,1,-3,1,1],[1,1,-1,3,3,-1],[3,1,-1,0,0,0]];#Resultant demodulated signal at mobile(Z(t-2Tc)) from path2\n", + "Rx=Rx1+Rx2; #since,Z(t)=z(t)+Z(t-2Tc)\n", + "\n", + "#from Figure 11.13 (d) & Figure 11.14\n", + "c1=[[-1,-1,-1,-1,1,1],[1,-1,1,1,-1,-1],[1,-1,1,-1,-1,-1],[-1,1,1,1,-1,1],[1,-1,-1,1,-1,1]];\n", + "c2=[[-1,1,-1,-1,-1,-1],[1,1,1,-1,1,1],[-1,-1,1,-1,1,-1],[-1,-1,-1,1,1,1],[-1,1,1,-1,-1,1],[-1,1,0,0,0,0]];\n", + "\n", + "#Calculations&Results\n", + "#case-1:Z(t)*C1(t);\n", + "for i in range(0,5):\n", + " Demod_1=c1[i][0]*Rx[i][0]+c1[i][1]*Rx[i][1]+c1[i][2]*Rx[i][2]+c1[i][3]*Rx[i][3]+c1[i][4]*Rx[i][4]+c1[i][5]*Rx[i][5];\n", + " if(Demod_1<0):\n", + " B1=1;\n", + " else:\n", + " B1=0;\n", + "\n", + "#case-2:Z(t)*C1(t-2Tc);\n", + "for j in range(0,5):\n", + " Demod_2=c2[j][2]*Rx[j][2]+c2[j][3]*Rx[j][3]+c2[j][4]*Rx[j][4]+c2[j][5]*Rx[j][5]+c2[j+1][0]*Rx[j+1][0]+c2[j+1][1]*Rx[j+1][1]-10\n", + " if(Demod_2<0):\n", + " B2=1;\n", + " else:\n", + " B2=0;\n", + "\n", + "print \"case-1:z(t)*c1(t)\";\n", + "print \"Value of integration at end of bit period for mobile(case-1)\",Demod_1\n", + "print \"The recovered signal at mobile(case-1) is \",B1\n", + "print \"Actual bit values are\",M1\n", + "print \"Recovered and actual values are not matching\",\n", + "\n", + "print \"\\n\\ncase-2:z(t)*c1(t-2Tc)\"\n", + "print \"Value of integration at end of bit period for mobile(case-2)\",Demod_2\n", + "print \"The recovered signal at mobile(case-2) is \",B2\n", + "print \"Actual bit values are\",M1\n", + "print \"Recovered and actual values are not matching\",\n", + "\n", + "#case3-Sum of path1 and path2\n", + "print \"\\n\\ncase-3:Sum of path1 & path2 integrator\"\n", + "Demod_3=Demod_1+Demod_2;\n", + "print \"Sum of integrator outputs(rake receiver output)\",Demod_3\n", + "\n", + "for k in range(0,5):\n", + " if(Demod_3<0):\n", + " B3=1;\n", + " else:\n", + " B3=0;\n", + " \n", + "print \"Detected bit value \",B3\n", + "print \"Actual bit values are\",M1\n", + "print \"Recovered and actual values are matching\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "case-1:z(t)*c1(t)\n", + "Value of integration at end of bit period for mobile(case-1) -12\n", + "The recovered signal at mobile(case-1) is 1\n", + "Actual bit values are [1, 0, 0, 1, 1]\n", + "Recovered and actual values are not matching \n", + "\n", + "case-2:z(t)*c1(t-2Tc)\n", + "Value of integration at end of bit period for mobile(case-2) -12\n", + "The recovered signal at mobile(case-2) is 1\n", + "Actual bit values are [1, 0, 0, 1, 1]\n", + "Recovered and actual values are not matching \n", + "\n", + "case-3:Sum of path1 & path2 integrator\n", + "Sum of integrator outputs(rake receiver output) -24\n", + "Detected bit value 1\n", + "Actual bit values are [1, 0, 0, 1, 1]\n", + "Recovered and actual values are matching\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.7, Page 360" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Prm=-97;#the signal strength from the base stations in dBm\n", + "#The constant ( K ) is the part of the broadcast message that is sent to the mobile by the base station on the paging channel.\n", + "K=-73; #dB\n", + "P2=18; #power as directed by BS (dBm)\n", + "\n", + "#Calculations&Results\n", + "Ptm=K-Prm;\n", + "print 'The mobile transmitter power be set as a first approximation of %d dBm'%Ptm\n", + "Pwr_Redu=Ptm-P2;#power reduction\n", + "print 'Power reduction = %d dBm'%Pwr_Redu\n", + "Time=6*1.25;\n", + "print 'Time required by mobile station to make changes as directed by base station is %.1f msec'%Time\n", + " " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The mobile transmitter power be set as a first approximation of 24 dBm\n", + "Power reduction = 6 dBm\n", + "Time required by mobile station to make changes as directed by base station is 7.5 msec\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.8, Page 362" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P1=-95; #pilot1 in dBm\n", + "P2=-100; #pilot2 in dBm\n", + "P3=-101; #pilot3 in dBm\n", + "P4=-105; #pilot4 in dBm\n", + "P5=-102; #pilot in dBm\n", + "NoiseP=-107; #Receiver sensitivity(dBm)\n", + "Tadd=-13; #dB\n", + "\n", + "#Calculations&Results\n", + "#Pcj = received power of the jth pilot in the candidate set\n", + "# Pai= received power of the ith pilot in the active set \n", + "Pa1=P1-NoiseP;\n", + "Pa2=P2-NoiseP;\n", + "Pa3=P3-NoiseP;\n", + "Pa4=P4-NoiseP;\n", + "Pc5=P5-NoiseP;\n", + "\n", + "X=10*math.log10(10**(0.1*Pa1)+10**(0.1*Pa2)+10**(0.1*Pa3)+10**(0.1*Pa4)+10**(0.1*Pc5)); \n", + "print \"Since P1>P2>P3>P4, we replace P4\"\n", + "T_COMP=(P5-P4)/0.5;\n", + "print 'The value of T-COMP that could trigger the mobile station to generate a PSMM should be <= %d dB (<= %d)'%(T_COMP,round(10**(0.1*T_COMP)));\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Since P1>P2>P3>P4, we replace P4\n", + "The value of T-COMP that could trigger the mobile station to generate a PSMM should be <= 6 dB (<= 4)\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb new file mode 100755 index 00000000..8234bb5b --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb @@ -0,0 +1,91 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:5a8dcdff9c441023f41d39cb4ab911bae195c143982b35aa0ceb85309af37715" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 12: Mobility Management in Wireless Networks" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.1, Page 374" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "P=10000; #Mobile density(mobiles/km**2)\n", + "R=500*10**-3; #km\n", + "V=10; #Average moving velocity of a mobile in Kmph\n", + "Nc=10.; #No of cells per LA\n", + "N_LA=5; #Number of LAs per MSC/VLR \n", + "\n", + "\n", + "#Calculations&Results\n", + "#Number of transactions and duration of each transaction to MSC/VLR per LU for different LU types are given in Table 12.1.(page no.374)\n", + "\n", + "\n", + "# L=length (km) of the cell exposed perimeter in an LA\n", + "L=6*R*(1./3+1./(2*math.sqrt(Nc)-3)); #Km\n", + "# lamdaLU=number of transactions processed by MSC/VLR in an LA perimeter of the jth cell per hour\n", + "LamdaLu=V*P*L/math.pi; #Lus per hour\n", + "\n", + "\n", + "# case(1)\n", + "print \"Case-1\"\n", + "R1_LU=LamdaLu/3600*(1*600./1000); #resource occupancy from Table 12.1\n", + "print 'The resource occupancy in the jth cell due to MS LUs is %.1f Erlangs'%R1_LU;\n", + "\n", + " \n", + "#case(2)\n", + "print \"\\nCase-2\"\n", + "R2_LU=LamdaLu/3600*(0.8*3500/1000+0.2*4000/1000); #from Table 12.1\n", + "print 'The resource occupancy in the jth cell due to MS LUs is %.2f Erlangs'%R2_LU;\n", + "Np=6*math.sqrt(Nc/3)-3;#Number of cells located on perimeter of an LA\n", + "print 'Number of cells where inter-VLR LUs occur will be: %d'%(round(0.5*Np*4));\n", + "print 'Number of cells where intra-VLR LUs occur will be: %d'%(4*Nc-16);\n", + "TNLU=LamdaLu*(2*24+16*(0.8*14+0.2*16)); #from table 12.1\n", + "print 'The MSC/VLR transaction load using the \ufb02uid \ufb02ow model is %.2e transactions at peak hour'%TNLU;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Case-1\n", + "The resource occupancy in the jth cell due to MS LUs is 10.1 Erlangs\n", + "\n", + "Case-2\n", + "The resource occupancy in the jth cell due to MS LUs is 60.55 Erlangs\n", + "Number of cells where inter-VLR LUs occur will be: 16\n", + "Number of cells where intra-VLR LUs occur will be: 24\n", + "The MSC/VLR transaction load using the \ufb02uid \ufb02ow model is 1.69e+07 transactions at peak hour\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb new file mode 100755 index 00000000..fec26202 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb @@ -0,0 +1,104 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:0963e656a45b56e87c82b1b894058e0c0c5d5a3acfd1e2f8850678ef319681b0" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 13: Security in Wireless Systems" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 13.1, Page 424" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "#Two prime numbers\n", + "p=5;\n", + "q=7;\n", + "\n", + "#Calculations\n", + "n=p*q;\n", + "z=(p-1)*(q-1);\n", + "e=5\n", + "d=29\n", + "\n", + "#Results\n", + "print 'Public keys is (%d, %d)'%(n,e);\n", + "print 'Private key is (%d, %d)'%(n,d);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Public keys is (35, 5)\n", + "Private key is (35, 29)\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 13.2, Page 425" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "p=23; #prime number that both parties agreed upon\n", + "g=5;# g is primitive mod p\n", + "a=6; #party A choosen number\n", + "b=15; #party B choosen number\n", + "\n", + "#Calculations&Results\n", + "print 'Party A sends to party B as (g**a mod p) = %d'%(g**a%23);\n", + "print 'Party B sends to party A as (g**b mod p) = %d'%(g**b%23);\n", + "print 'Party A computes secret key as ((g**b modp)**a mod p) = %d'%(((g**b%23)**a)%p);\n", + "print 'Party B computes secret key as ((g**a modp)**b mod p) = %d'%(((g**a%23)**b)%p);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Party A sends to party B as (g**a mod p) = 8\n", + "Party B sends to party A as (g**b mod p) = 19\n", + "Party A computes secret key as ((g**b modp)**a mod p) = 2\n", + "Party B computes secret key as ((g**a modp)**b mod p) = 2\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb new file mode 100755 index 00000000..58285a29 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb @@ -0,0 +1,106 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:3bb6fed41815ab02f5db449f0fb6dc3bca89d7411c6822dfe382fccc1777b7c3" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 14: Mobile Network and Transport Layer" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 14.1, Page 452" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "O=800*1000; #Object size(Bytes)\n", + "S=536.*8; #max Segment Size(in bits)\n", + "RTT=0.1; #Round trip-time in sec\n", + "R=1.*10**6; #Transmission rate of the link from the server to the client in bps\n", + "\n", + "#Calculations\n", + "Lmin=2*RTT+(O/R); #latency(msec)\n", + "# For minimum latency (S/R) +RTT -(W*S/R) = 0;Therefore\n", + "W=1+(RTT)/(S/R);\n", + "\n", + "#Results\n", + "print 'The minimum possible latency is %d sec'%Lmin;\n", + "print 'The minimum window size is %.1f segments'%W;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The minimum possible latency is 1 sec\n", + "The minimum window size is 24.3 segments\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 14.2, Page 452" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "RTT=0.1; #Round trip-time in sec\n", + "MSS=536.*8; #Maximum segment size in bits\n", + "p=0.01;# packet loss probability for the path\n", + "RTO=5*RTT; #Retransmission time out(from eqn 14.2 on page 450)\n", + "\n", + "#Calculations\n", + "R=0.93*MSS/(RTT*math.sqrt(p));\n", + "RR=MSS/(RTT*math.sqrt(1.33*p)+RTO*p*(1+32*p**2)*min(1,3*math.sqrt(0.75*p)));\n", + "\n", + "#Results\n", + "print 'The upper bound of the throughput is %.4f Mbps'%(R*10**-6);\n", + "print 'The throughput with retransmission due to errors is %.4f Mbps'%(RR*10**-6);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The upper bound of the throughput is 0.3988 Mbps\n", + "The throughput with retransmission due to errors is 0.3341 Mbps\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb new file mode 100755 index 00000000..708d447e --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb @@ -0,0 +1,769 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:029905df97aa37359789733a28b442f75b82e79e7e96006449e39c092f0d4cca" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 17: Planning and Design of a Wireless Network" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.1, Page 597" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration \n", + "Susage=150.;#subscriber usage per month in mins\n", + "days=24;#days per month\n", + "busyhrs=6;#in a day\n", + "BW=4.8*10**3; #in kHz\n", + "Freqreuse=4./12;#Frequency reuse plan\n", + "chwidth=200; #in kHz\n", + "subscriber=50000;#Present subscriber count\n", + "Sgrowth=0.05;#Growth rate per year\n", + "Area=500; #in km\n", + "BTScapacity=30; #in Erlangs\n", + "N=4; #Initial installation design years\n", + " \n", + "#Calculations&Results\n", + "Erlangspersub=Susage/(days*busyhrs*60);\n", + "print 'Average busy-hour traf\ufb01c per subscriber is %.4f Erlangs'%Erlangspersub;\n", + "RFcarriers=BW/chwidth;\n", + "RFcarrier_percell=RFcarriers/((Freqreuse**-1)*4); #freq reuse factor of 4\n", + "\n", + "#Assuming 2 control channels per cell\n", + "CC=2;#control channels\n", + "TC_percell=2*RFcarriers/3-CC;\n", + "#Referring Erlang-B table in Appendix A\n", + "print \"Referring Erlang-B table in Appendix A,Traf\ufb01c capacity of a GSM cell at 2% GoS for 14 channels = 8.2 Erlangs \"\n", + "Tcapacity=8.2;# in Erlangs\n", + "print \"There are 3 cells per BTS\"\n", + "BTS=3;\n", + "Traffic_perBTS=Tcapacity*BTS;\n", + "print 'Traffic capacity per BTS is %.1f Erlangs'%Traffic_perBTS\n", + "print \"Therefore, Traffic per BTS is less than BTS capacity(30 Erlangs)\"\n", + "maxsubscriber=Traffic_perBTS/Erlangspersub;\n", + "initialsub=subscriber*(1+Sgrowth)**N;\n", + "BTS_perZone=initialsub/maxsubscriber;\n", + "print 'The required number of base stations per zone are %d'%(round(BTS_perZone));\n", + "cellRadius=(Area/(BTS_perZone*2.6))**0.5;\n", + "print 'The hexagonal cell radius is %.1f km'%cellRadius;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average busy-hour traf\ufb01c per subscriber is 0.0174 Erlangs\n", + "Referring Erlang-B table in Appendix A,Traf\ufb01c capacity of a GSM cell at 2% GoS for 14 channels = 8.2 Erlangs \n", + "There are 3 cells per BTS\n", + "Traffic capacity per BTS is 24.6 Erlangs\n", + "Therefore, Traffic per BTS is less than BTS capacity(30 Erlangs)\n", + "The required number of base stations per zone are 43\n", + "The hexagonal cell radius is 2.1 km\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.2, Page 598" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "usage=150.; #subscriber usage per month in mins\n", + "days=24;#Days in a month\n", + "BHrs=6;#Busy hours per day\n", + "BW=4.8; #in MHz\n", + "RFch=200; #in kHz\n", + "Psubscribers=50000;#present subscriber count\n", + "growth=0.05;#subscriber growth per year\n", + "rollover=4;#network roll over period\n", + "NPCS=5;#Number of packet calls per session \n", + "NPP=25;#Number of packets within a packet call \n", + "Tr=120;#Reading time between packet calls(sec)\n", + "NBP=480*8;#Packet size(in bits)\n", + "Tint=0.01;#Time interval between two packets(sec)\n", + "Ttot=3000;#Total packet service holding time\n", + "BH_PS=0.15;#Busy hour packet sessions per subscriber\n", + "Penetration=0.25;\n", + "datarate=48; #in kbps\n", + "PTT=10;#Packet transmission time(sec)\n", + "BTS=40;#NO of BTS sites\n", + "\n", + "#Calculations&Results\n", + "Bitstx_duringPTT=NPCS*NPP*NBP/1000; \n", + "PST=PTT+Tr*(NPCS-1)+Tint*(NPP-1);\n", + "PT_duringBH=BH_PS*Ttot/PST;\n", + "Bits_persub_persec=Bitstx_duringPTT*PT_duringBH/(60*60);\n", + "VoiceErlangs=usage/(days*BHrs*60);\n", + "Initial_subscribers=round(Psubscribers*(1+growth)**rollover);\n", + "Data_subscribers=Initial_subscribers*Penetration;\n", + "Totalvoice=Initial_subscribers*VoiceErlangs;\n", + "Voicetraffic_perBTS=Totalvoice/BTS;\n", + "print 'Voice Traffic per Cell(sector) is %.2f Erlangs'%(Voicetraffic_perBTS/3);\n", + "Totaldata=Data_subscribers*Bits_persub_persec;\n", + "Datathroughput_perBTS=Totaldata/BTS;\n", + "print 'Data throughput per Cell(sector) is %.2f kbps'%(Datathroughput_perBTS/3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voice Traffic per Cell(sector) is 8.79 Erlangs\n", + "Data throughput per Cell(sector) is 15.50 kbps\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.3, Page 600" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Holdtime=120;#Average holding time during Busy Hours(in sec)\n", + "Tx=3;# No of transreceivers\n", + "TSsig=3;#No of TSs per cell for signaling\n", + "RLC=0.80;#Radio link control efficiency\n", + "Radioblocks=9000;#Total numbers of transmitted radio blocks\n", + "TSdata=3;#TSs allocated for data traf\ufb01c per cell\n", + "Datarate=15.5; #From eg 17.2\n", + "Voicetraffic=8.82; #From eg.17.2\n", + "Duration=0.02;#Duration of block in sec\n", + "\n", + "#Calculations&Results\n", + "DataEr=Radioblocks*Duration/Holdtime;\n", + "print 'Data Erlangs = %.1f'%DataEr;\n", + "TSuti=DataEr/TSsig;\n", + "print 'Time Slot(TS) utilization = %.1f'%TSuti;\n", + "Throughput=(Datarate/TSdata)*RLC;\n", + "TScap=Throughput/TSuti;\n", + "print 'TS capacity is %.2f kbps'%TScap;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Data Erlangs = 1.5\n", + "Time Slot(TS) utilization = 0.5\n", + "TS capacity is 8.27 kbps\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.4, Page 602" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Pt=36;#Base station transmitted power in dBm\n", + "Pms=24;#mobile station transmitted power in dBm\n", + "Nms=8;#mobile station noise figure in dB\n", + "Nbs=5;#Base station nise figure in dB\n", + "Ga=18;#Base station transmit and receive antenna gain in dBi\n", + "Gm=0;#Mobile antenna gain in dBi\n", + "SNR=12;# in dB\n", + "Lc_TX=5;#BS transmit antenna cable, connector, and \ufb01lter losses in dB\n", + "Lc_RX=2;#BS receiver antenna cable, connector, and \ufb01lter losses in dB\n", + "Bodyloss=3;# Body losses at mobile\n", + "fading=10.2;# in dB\n", + "ThermalNoise=-174;# in dBm/Hz\n", + "Gdiversity=5;#Antenna diversity gain at BS in dB\n", + "#Assuming standard value of RF channel as \n", + "RFch=200*10**3; #in Hz\n", + "\n", + "#Calculations\n", + "N=ThermalNoise+10*math.log10(RFch)+Nms;\n", + "Smin=N+SNR;\n", + "Smean=Smin+fading+Bodyloss;\n", + "Lp=Pt-Lc_TX+Ga-Smean;\n", + "N1=ThermalNoise+10*math.log10(RFch)+Nbs;\n", + "Smin=N1+SNR-Gdiversity;\n", + "Smean1=Smin+fading+Bodyloss;\n", + "Lp1=Pms-Smean1+Ga-Lc_RX;\n", + "R=10**((Lp1-133.2)/33.8);\n", + "\n", + "#Result\n", + "print 'Cell radius is %.1f km'%R;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Cell radius is 1.2 km\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.5, Page 608" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Ri=12.2*10**3;#Information rate in bps\n", + "Rc=3.84*10**6;#Chip rate in cps(chips per second)\n", + "Eb_Nt=4.; #in dB\n", + "Imargin=2.; #Interference margin(3 dB)\n", + "B=0.5;#Interference factor due to other cells\n", + "Vi=0.65;#Channel activity factor\n", + "\n", + "#Calculations&Results\n", + "Eb_Ntreqd=10**(Eb_Nt/10);\n", + "LF_peruser=(1+B)*(1./(1+(Rc/Ri)*(1./Eb_Ntreqd)*(1./Vi))); #M(no of users=1) in Eq 17.13\n", + "print 'Cell load factor per voice user is %.5f'%LF_peruser;\n", + "CellLoading=(Imargin-1)/Imargin;\n", + "VoiceUsers=CellLoading/LF_peruser;\n", + "print 'No of Voice Users are %d per cell'%VoiceUsers;\n", + "#From EQ 17.6 assuming Power control efficiency=1\n", + "Polecap=Rc/(Ri*Vi*(1+B)*Eb_Ntreqd);\n", + "print 'Pole Capacity is %d'%Polecap;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Cell load factor per voice user is 0.00774\n", + "No of Voice Users are 64 per cell\n", + "Pole Capacity is 128\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.6, Page 608" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Eb_Nt=1.; #in dB\n", + "cellLoading=0.5;#Required interference margin(3 dB)\n", + "B=0.5;#Interference factor due to other cells\n", + "Vi=1;#Channel activity factor\n", + "\n", + "#Calculations\n", + "Eb_Ntreqd=10**(Eb_Nt/10);\n", + "#Assuming standard value of chip rate as 3.84Mcps\n", + "Rc=3.84*10**6;#in cps(chips per second)\n", + "Throughput=(cellLoading*Rc)/(Eb_Ntreqd*(1+B));\n", + "\n", + "#Result\n", + "print 'Uplink Throughput is %d kbps'%(Throughput/1000);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Uplink Throughput is 1016 kbps\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.7, Page 610" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Ri=12.2*10**3;#Information rate in bps\n", + "Rc=3.84*10**6;# Chip rate in chips per second\n", + "Eb_Nt=4.; # in dB\n", + "Eb_Nt=10**(Eb_Nt/10);\n", + "B=0.5;#Average interference factor due to other cells\n", + "Zeta=0.6; # orthogonality factor\n", + "Imargin=2.;#Interference margin(3 dB)\n", + "Vi=0.65 #assuming Channel activity factor as 0.65\n", + "\n", + "#Calculations&Results\n", + "Loadfactor_peruser=(Zeta+B)*(1./((Rc/Ri)*(1./Eb_Nt)*(1./Vi)))\n", + "print 'Downlink cell load factor is %.4f'%Loadfactor_peruser;\n", + "cellLoading=(Imargin-1)/Imargin;\n", + "Voiceusers=cellLoading/Loadfactor_peruser;\n", + "print 'No of voice users per cell are %d'%Voiceusers;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Downlink cell load factor is 0.0057\n", + "No of voice users per cell are 87\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.8, Page 610" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "N0=-174;#Noise density in dBm/Hz\n", + "Bc=1.25;#Channel bandwidth in mHz\n", + "Rc=1.2288;#Chip rate in Mcps\n", + "Nf=6; #Receiver Noise figure in dB\n", + "Pt=27; #Effective radiated power from mobile in dBm\n", + "Lct=0.5; #Transmitter cable and connector loss in dBm\n", + "Lbody=1.5;#Body loss in dB\n", + "Lcr=2; #Receiver cable and connector loss in dB\n", + "Mint=0; #Interference margin in dB\n", + "Mfading=2;#fast fadinf margin in dB\n", + "Lpent=8;#Penetration loss in dB\n", + "Gm=0;#Transmitter antennna gain in dBi\n", + "Gb=12;#Receiver antenna gain in dBi\n", + "Fm=8;#Fade margin in dB\n", + "Eb_Nt=7;# in dB\n", + "\n", + "#Calculations\n", + "Nth=N0+Nf;\n", + "S_Nt=Eb_Nt+10*math.log10((Rc*10**6)/(Bc*10**6));\n", + "Smin=S_Nt+10*math.log10(Rc*10**6)+Nth;\n", + "Lpmax=(Pt-Smin)+(Gb+Gm)-(Lbody+Lct+Lcr+Fm+Lpent)-Mint-Mfading;\n", + "\n", + "#Results\n", + "print 'Minimum signal power required is %.2f dBm'%Smin;\n", + "print 'Maximum allowable path loss is %.2f dB'%Lpmax;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum signal power required is -100.18 dBm\n", + "Maximum allowable path loss is 117.18 dB\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.9, Page 612" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Rc=3.84;#Chip rate in Mcps\n", + "Ri=16;#Data rate in kbps\n", + "UL=0.5;#UL loading factor\n", + "DL=0.9;#DL loading factor\n", + "Eb_NtU=4;#in dB\n", + "Eb_NtD=6;# in dB\n", + "Gm=0;#Mobile antenna gain in dBi\n", + "Gb=18;#Base station gain in dBi\n", + "\n", + "#Calculations\n", + "R=10**((139.65-138.5)/35.7);\n", + "print 'Cell Radius is %.3f km'%R;\n", + "Area=round(2.6*R**2);\n", + "\n", + "#Results\n", + "print 'Area covered by hexagonal cell is %d km**2'%Area;\n", + "print 'Number of BTSs required to cover an area of 2400 Km**2 are %d'%(2400/Area);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Cell Radius is 1.077 km\n", + "Area covered by hexagonal cell is 3 km**2\n", + "Number of BTSs required to cover an area of 2400 Km**2 are 800\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.10, Page 614" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Rc=3.84;#chip rate in Mcps\n", + "N=3.;#Noise rise in dB\n", + "OF=0.8;#orthogonality factor\n", + "B=0.55;#Interference from other cells \n", + "Eb_N0=4.;#in dB\n", + "Sec_Eff=0.85;#Sector efficiency\n", + "Pwr_Eff=0.80;#Power control efficiency\n", + "Y=1.2; #Retransmit rate\n", + "X=10.; #10MB at 384Kbps\n", + "X1=2.; #2MB at 144Kbps\n", + "X2=1.; #1MB at 64Kbps\n", + "\n", + "#Calculations\n", + "#Assuming Voice activity=Vf=1\n", + "Vf=1;\n", + "AvgDR=Y*X*10**6*(1./3600)+Y*X1*10**6*(1./3600)+Y*X2*10**6*(1./3600);\n", + "CLoad=(N-1)/(N+1);\n", + "DLcap=(Rc*10**6*Pwr_Eff*Sec_Eff)/(((10**(Eb_N0/10))*(B+OF)*Vf));\n", + "Allowcap=CLoad*DLcap;\n", + "users=Allowcap/AvgDR;\n", + "\n", + "#Result\n", + "print 'NO of users that can be supported on the downlink of the WCDMA network are %d'%(round(users));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "NO of users that can be supported on the downlink of the WCDMA network are 89\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.11, Page 616" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "P1=1./2;#relative frequency of packets for user class1 \n", + "P2=1./3;#relative frequency of packets for user class2\n", + "P3=1./6;#relative frequency of packets for user class3\n", + "R1=16; #data rate in kbps for P1\n", + "R2=64; #data rate in kbps for P2\n", + "R3=1024; #data rate in kbps for P3\n", + "S1=16;#number of slots assigned to the R1 user\n", + "S2=8;#number of slots assigned to the R2 user\n", + "S3=2;#number of slots assigned to the R3 user\n", + "\n", + "#Calculations\n", + "#Using Equation 17.20 from page no 616\n", + "Ravg=(P1*R1*S1+P2*R2*S2+P3*R3*S3)/(P1*S1+P2*S2+P3*S3);\n", + "# For equal latency, using Eq 17.18\n", + "Rav=1./(P1/R1+P2/R2+P3/R3);\n", + "# For Latency ratio=4, using Eq 17.19 from page no 616\n", + "PL=4;\n", + "C=(P1+P2+PL*P3)/(P1/R1+P2/R2+P3/R3);\n", + "\n", + "#Results\n", + "print 'The average throughput for equal access condition is %.1f kbps'%Ravg;\n", + "print 'The average throughput by considering equal latency is %.1f kbps'%Rav;\n", + "print 'The average throughput by considering latency ratio as 4 is %.2f kkbps'%C\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The average throughput for equal access condition is 58.2 kbps\n", + "The average throughput by considering equal latency is 27.3 kbps\n", + "The average throughput by considering latency ratio as 4 is 40.96 kkbps\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.12, Page 620" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Ec_Nt=-23.;#in dB\n", + "DRC=-1.5;#DRC gain with respect to pilot in dB\n", + "Tg=3.75; # Traf\ufb01c channel gain with respect to pilot in dB\n", + "B=0.85;#Interference factor due to other cells \n", + "\n", + "#Calculations\n", + "Mmax=(1./(1+10**(DRC/10)+10**(Tg/10)))*(1./((10**(Ec_Nt/10)*(1+B))));\n", + "#The sector loading can be expressed as a fraction of the pole capacity Mmax. This is typically 70% of the pole capacity. \n", + "M_allow=int(0.7*Mmax);\n", + "#From table 17.2 we get Traffic channel rate as 9.6kbps since we are given traffic channel gain with respect to pilot as 3.75 dB\n", + "Ri=9.6; #in kbps(see table 17.2)\n", + "Tput=Ri*M_allow;\n", + "\n", + "#Result\n", + "print 'Allowable reverse link throughput is %d kbps'%(round(Tput));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Allowable reverse link throughput is 173 kbps\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.13, Page 623" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Ptmax=5.5;#Maximum transmit power of DSCH in watts\n", + "Pbs=18;# Total base station power in watts\n", + "alpha=0.2;#downlink orthogonality factor \n", + "G=0.363;# geometry factor\n", + "SF=16; #Spreading Factor for DSCH;fixed at value of 16\n", + "\n", + "#Calculations\n", + "# Using equation no 17.27 given on page no 623\n", + "SINR=SF*(Ptmax/(Pbs*(1-alpha+(1/G))));\n", + "# In dB\n", + "SINR_db=10*math.log10(SINR);\n", + "\n", + "#Result\n", + "print 'The average SINR of HSDPA is %.4f dB(%.1fdB)'%(SINR,SINR_db);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The average SINR of HSDPA is 1.3753 dB(1.4dB)\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.14, Page 624" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Users=350;#no of users supported\n", + "ExpectedTraf=1.8; # From section 17.7 (in Kbps)\n", + "BHTraf=1.785;#Busy hour traffic in kbps\n", + "BTS=180;\n", + "\n", + "#Calculations\n", + "IubBW=(ExpectedTraf*Users*BHTraf)/1000; # in Mbps\n", + "TotalBW=BTS*IubBW;\n", + "\n", + "#Result\n", + "print 'Required total bandwidth of Iub Interface is %.2f Mbps'%TotalBW;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required total bandwidth of Iub Interface is 202.42 Mbps\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.15, Page 625" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "BTS=800.;#No of BTS sites\n", + "Sec=3;#No of sectors per BTS\n", + "freq_sec=2;#No of frequencies used per sector\n", + "cellsRNC=1152;#Maximum capacity of cellRNC\n", + "btsRNC=384;#One RNC can support btsRNC(BTSs)\n", + "VE=25;#Voice service(mErl/subscriber)\n", + "BRV=16;# bitrate Voice\n", + "CS1=10;#CS data service 1(mErl/subscriber)\n", + "BRC1=32;#bit rate for CS1 in kbps\n", + "CS2=5;#CS data service 2(mErl/subscriber)\n", + "BRC2=64;##bit rate for CS2 in kbps\n", + "PSdata=0.2;#PS data service(kbps per subscriber)\n", + "PSoverhead=0.15;\n", + "SHO=0.4;#40%\n", + "Totalsub=350000;#Total subsribers\n", + "Maxcap=196;#Maximum Iub capacity of tpRNC (in Mbps)\n", + "FR1=0.9;FR2=0.9;FR3=0.9;#Filler rates\n", + "\n", + "#Calculations&Results\n", + "RNCreqd=(BTS*Sec*freq_sec)/(cellsRNC*FR1);#from eqn 17.28\n", + "print 'using equation 17.28,Number of RNC required are %d'%(round(RNCreqd));\n", + "RNC_reqd=BTS/(btsRNC*FR2);#from eqn 17.29\n", + "print 'using equation 17.29,Number of RNC required are %d'%(round(RNC_reqd));\n", + "RNCrequired=((VE/1000*BRV+CS1/1000*BRC1+CS2/1000*BRC2+(PSdata/(1-PSoverhead)))*(1+SHO)*Totalsub)/(Maxcap*1000*FR3);#from eqn 17.30\n", + "print 'using equation 17.30,Number of RNC required are %d'%(round(RNCrequired));\n", + "print 'We select first value which is %d RNCs'%(round(RNCreqd));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "using equation 17.28,Number of RNC required are 5\n", + "using equation 17.29,Number of RNC required are 2\n", + "using equation 17.30,Number of RNC required are 1\n", + "We select first value which is 5 RNCs\n" + ] + } + ], + "prompt_number": 15 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb new file mode 100755 index 00000000..fee9ff09 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb @@ -0,0 +1,106 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:dd18f098648291d58cdb32b1739d692bc9e7a8620a737fa84a463a3efca95463" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 19: Wireless Personal Area Network - Bluetooth" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 19.1, Page 666" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "SS=80.; #Frame length of HV3 voice packet\n", + "R=64*10**3; #Data rate in bps\n", + "TS=240; #No of bits carried in a slot\n", + "\n", + "#Calculations\n", + "#From table 19.3:Bluetooth air interface details, we get Frequency hopping rate as 1600hopes/second\n", + "\n", + "#From table 19.5, we can note that for HV3, No of slots are 1 and carry in all(80(user voice sample)+160(parity bits))=240 bits in one slot packet\n", + "HR=1600; #hopes/second\n", + "Eff=SS/TS;\n", + "x=R/SS; #x is number of times a packet is sent\n", + "\n", + "#Results\n", + "print 'Hopping rate is %d hopes/sec'%HR;\n", + "print 'No of bits transmitted in one slot are %d'%TS;\n", + "print 'Efficiency of packet transmission is %.4f'%Eff;\n", + "print 'Number of times a packet is sent is equal to %d'%x;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Hopping rate is 1600 hopes/sec\n", + "No of bits transmitted in one slot are 240\n", + "Efficiency of packet transmission is 0.3333\n", + "Number of times a packet is sent is equal to 800\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 19.2, Page 666" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "R=136.; # bits per slot\n", + "SR=800; # no of slots per second\n", + "\n", + "#Calculations\n", + "# A symmetric 1-slot DM1 link is setup between a master and a slave\n", + "AR=R*SR; #Data rate in bps\n", + "\n", + "#Result\n", + "print 'Associated data rate is %0.1f kbps'%(AR/1000);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Associated data rate is 108.8 kbps\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb new file mode 100755 index 00000000..b82f7950 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb @@ -0,0 +1,533 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:dd4432cc2f7e790571ec64d7a8254cb368aab6a22204c8b382ba85e3c1b5a734" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 2: Teletraffic Engineering" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.1, Page 25" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "LC=10.; #Lost calls\n", + "CC=380; #Carried calls\n", + "\n", + "#Calculations\n", + "OC=LC+CC; #Total offered calls\n", + "#Gos=Blocking probability=(number of Lost calls/Total number of offered calls)\n", + "Gos=LC/OC;\n", + "\n", + "#Result\n", + "print 'The Gos during busy hour is %f \\n '%Gos" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Gos during busy hour is 0.025641 \n", + " \n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.2, Page 26" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Ht=5; #Average holding time in seconds\n", + "PC=450; # Peg count for one hour period\n", + "OC=0; # Overflow count\n", + "\n", + "#Calculations&Results\n", + "# usage(Erlangs)=(peg count- overflow count)*Average holding time(in hrs)\n", + "U=(PC-OC)*(5./3600); \n", + "print 'Usage = %.3f Erlangs'%U\n", + "\n", + "# IN CCS\n", + "Uccs=U*36; # usage in CCS\n", + "print '%.1f CCS'%Uccs\n", + "\n", + "Ucs=Uccs *100; #usage in call-seconds\n", + "print '%d call-seconds'%Ucs" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Usage = 0.625 Erlangs\n", + "22.5 CCS\n", + "2250 call-seconds\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.3, Page 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "B=0.05; #Blocking(5%)\n", + "CL=3000.; #Carried Load in CCS\n", + "\n", + "#Calculations\n", + "#Offered Load=Carried Load/(1-Blocking);\n", + "OL=CL/(1-B); #Offered Load in CCS\n", + "\n", + "#Result\n", + "print 'Offered load is %d CCS'%OL\n", + "print 'Overflow is %d CCS'%((OL-CL))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Offered load is 3157 CCS\n", + "Overflow is 157 CCS\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.4, Page 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Ht=120; #Holding time in seconds\n", + "CR=2.; #call rate per hour\n", + "\n", + "#Calculations\n", + "#Traffic Intensity(Erlangs) = call rate * Holding time(in hrs));\n", + "I=CR*Ht/3600; #Traffic Intensity\n", + "\n", + "#Result\n", + "print 'Traffic Intensity is %.4f Erlangs = %.1f CCS \\n'%(I,I*36);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Traffic Intensity is 0.0667 Erlangs = 2.4 CCS \n", + "\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.5, Page 27" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "time=90.; #in minutes\n", + "calls=10.; #no of calls in 90mins\n", + "\n", + "#Calculations\n", + "CR=calls/(time/60); #call arrival rate in calls/hour\n", + "tavg=(60.+74+80+90+92+70+96+48+64+126)/10; #average call holding time in sec per call\n", + "I= CR*(tavg/3600); #traffic intensity in Erlangs\n", + "\n", + "#Result\n", + "print 'Traffic Intensity is %.3f Erlangs = %.2f CCS \\n '%(I,I*36)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Traffic Intensity is 0.148 Erlangs = 5.33 CCS \n", + " \n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.6, Page 28" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "time=8.; #in hours\n", + "calls=11.; #no of calls in 90mins period\n", + "\n", + "#Calculations&Results\n", + "CR=calls/time; #call arrival rate in calls/hour\n", + "tavg=(3+10.+7+10+5+5+1+5+15+34+5)/11; #average call holding time in mins per call\n", + "I= CR*(tavg/60); #traffic intensity in Erlangs\n", + "print 'Traffic Intensity during eight hour period is %.3f Erlangs = %.1f CCS \\n'%(I,I*36);\n", + "\n", + "#For Busy Hour i.e between 4:00PM and 5:00PM\n", + "CRB=2; #call arrival rate during busy hour in calls/hour(from table 2.2)\n", + "tavgB=(34+5.)/2; #average holding time during Busy Hour in mins/call (from table 2.2)\n", + "IB=CRB*(tavgB/60); #Traffic Intensity during Busy Hour\n", + "print 'Traffic Intensity during busy hour is %.2f Erlangs = %.1f CCS'%(IB,IB*36);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Traffic Intensity during eight hour period is 0.208 Erlangs = 7.5 CCS \n", + "\n", + "Traffic Intensity during busy hour is 0.65 Erlangs = 23.4 CCS\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.7, Page 29" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "minutes=500.; #No of minutes used per month per user\n", + "Twork=0.9; #Traffic During Work day\n", + "TBH=0.1; #Traffic during busy hour\n", + "Days=20; #No of workdays in a month\n", + "\n", + "#Calculations\n", + "#Avg BH usage per subscriber (in minutes) = minutes*Twork(TBH/Days);\n", + "Traffic=minutes*Twork*(TBH/Days);\n", + "\n", + "#Result\n", + "print 'Traffic per user per BH is %.4f Erlangs \\n'%(Traffic/60);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Traffic per user per BH is 0.0375 Erlangs \n", + "\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.8, Page 29" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "minutes=500.; #No of minutes used per month per user\n", + "Twork=0.9; #Traffic During Work day\n", + "TBH=0.1; #Traffic during busy hour\n", + "Days=20; #No of workdays in a month\n", + "MeanHT=100; #Mean holding time(in secs)\n", + "\n", + "#Calculations\n", + "#Avg BH usage per subscriber (in minutes) = minutes*Twork(TBH/Days);\n", + "#BHCAs=traf\ufb01c (in Erlangs) *3600/(meanHT)\n", + "\n", + "Traffic=minutes*Twork*(TBH/Days);\n", + "BHCAs=(Traffic/60)*(3600/MeanHT);\n", + "\n", + "#Result\n", + "print 'Average Busy Hour call attempts are %.2f'%BHCAs" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average Busy Hour call attempts are 1.35\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.9, Page 35" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Tpopu=200000;#Total population\n", + "SP=0.25; #subscriber penetration\n", + "HT1=100.; #holding time for Mobile to Land line and vicecersa\n", + "c1=3; #Avg calls/hr for Mobile to Land line and vicecersa\n", + "HT2=80.; #For mobile to mobile\n", + "c2=4; #For mobile to mobile\n", + "TMSC=1800; #traffic one msc can hold\n", + "TrafDist=0.9 #Traffic distribution for Mobile to Land line and vicecersa\n", + "\n", + "#Calculations\n", + "aM_L=c1*HT1/3600; #Traffic Generated by Subscriber (M-L and L-M).\n", + "aM_M=c2*HT2/3600; #Traffic Generated by Subscriber (M-M).\n", + "WlessSub=SP*Tpopu; #total wireless subscribers\n", + "TotalTraffic=WlessSub*TrafDist*aM_L+WlessSub*(1-TrafDist)*aM_M;\n", + "MSCreqd=TotalTraffic/TMSC;\n", + "if(MSCreqd-int(MSCreqd)>0):#for rounding of to next integer ef 2.33 to 3\n", + " MSCreqd=MSCreqd+1;\n", + " \n", + "\n", + "#Result\n", + "print 'Total Traffic is %.1f Erlangs'%TotalTraffic;\n", + "print 'NO of MSCs Required are %d'%(int(MSCreqd))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total Traffic is 4194.4 Erlangs\n", + "NO of MSCs Required are 3\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.10, Page 37" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Rlines=15000.;#Residential lines\n", + "Blines=80000.;#Business lines\n", + "PWElines=5000;#PBX, WATS, and Foreign Exchange (FX) lines\n", + "CR_R=2.;#Call rates for Rlines\n", + "CR_B=3.;# call rates for Blines\n", + "CR_PWE=10.;#call rates for PWElines\n", + "HT_R=140.;#average holding time for Rlines(sec)\n", + "HT_B=160.;#average holding time for Blines(sec)\n", + "HT_PWE=200.;#average holding time for PWE lines(sec)\n", + "Slines=100000.;# no of lines carried by switch\n", + "HD_ABS=1.5;# HD/ABS for the switch\n", + "\n", + "#Calculations\n", + "percentR_lines=Rlines/Slines;\n", + "percentB_lines=Blines/Slines;\n", + "percentPWE_lines=PWElines/Slines;\n", + "CCSR=CR_R*HT_R/100;\n", + "CCSB=CR_B*HT_B/100;\n", + "CCSPWE=CR_PWE*HT_PWE/100;\n", + "\n", + "CR=CR_R*percentR_lines+CR_B*percentB_lines+CR_PWE*percentPWE_lines;\n", + "print 'The call rate is %.1f calls per line \\n '%CR\n", + "CCS=CCSR*percentR_lines+CCSB*percentB_lines+CCSPWE*percentPWE_lines;\n", + "AvgHTperline=CCS*100/CR;\n", + "ABS_BH_calls=CR*Slines;\n", + "ABS_BH_usage=CCS/36*Slines;\n", + "print 'Design cell capacity based on HD is %d calls \\n'%(HD_ABS*ABS_BH_calls);\n", + "print 'DESIGN Erlangs based on HD is %d \\n'%(round(HD_ABS*ABS_BH_usage)); " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The call rate is 3.2 calls per line \n", + " \n", + "Design cell capacity based on HD is 480000 calls \n", + "\n", + "DESIGN Erlangs based on HD is 21917 \n", + "\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.11, Page 43" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "maxcalls_hour=4000.;#maximum call per hour\n", + "avgHT=160.;#average holding time in sec\n", + "Gos=0.02;\n", + "\n", + "#Calculations&Results\n", + "A=maxcalls_hour*avgHT/3600; #offered load\n", + "print 'Offered load A = %.2f Erlangs \\n'%A\n", + "#Refering Appendix A i.e Erlang B table \n", + "print \"For calculated Offered load and referring Erlang B table we get Service channels as 182 giving 168.3 Erlangs at 2% blocking\"\n", + "#Incorrect answer in textbook" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Offered load A = 177.78 Erlangs \n", + "\n", + "For calculated Offered load and referring Erlang B table we get Service channels as 182 giving 168.3 Erlangs at 2% blocking\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.12, Page 43" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "channels=50;\n", + "blocking=0.02;\n", + "HT=120;#average holding time inm sec\n", + "BHcall=1.2;# in calls per hour\n", + "\n", + "#Calculations\n", + "#Refering Erlang B table in appendix A, For 50 channels at 2% blocking, the offered load=40.26 Erlangs.\n", + "A=40.26;\n", + "B=A*(1-0.02); #carried load\n", + "Avgtraffic_user=BHcall*HT/3600;\n", + "No_users=B/Avgtraffic_user;\n", + "\n", + "#Result\n", + "print 'NO of mobile subscribers supported are %d \\n'%(round(No_users))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "NO of mobile subscribers supported are 986 \n", + "\n" + ] + } + ], + "prompt_number": 29 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb new file mode 100755 index 00000000..8bbb0588 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb @@ -0,0 +1,476 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:0dee4e43707ceeefa5dfd2c385df6788c5d4953bcdfe972a22a90a0c7cd8abc7" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 21: Wireless Local Area Networks" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.1, Page 727" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import sympy\n", + "from sympy import * \n", + "\n", + "#Variable declaration\n", + "Fl=902; #lower limit frequency MHz\n", + "Fh=928; #higher limit frequency in MHz\n", + "Rt=0.5; #symbol transmission rate in Mega symbols per sec\n", + "S=16; #No of symbols\n", + "BER=10**-5;#Bir error rate\n", + "SG=2.6;#sector gain\n", + "B=0.5; #Interference factor\n", + "a=0.9; #power control efficiency\n", + "\n", + "#Calculations&Results\n", + "BW=Fh-Fl;\n", + "Rb=Rt*math.log(S,2);\n", + "Gp=BW/Rb;\n", + "x = symbols('x')\n", + "y = solve(0.5*(1-erf(sqrt(x)))-10**-5,x)\n", + "M=Gp/y[0] * 1/(1+B) * SG * a;\n", + "print 'Number of users that can be supported by the WLAN are %d'%M\n", + "eff=Rb*int(M)/BW;\n", + "print 'The bandwidth efficiency is %.2f bps/Hz'%eff" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Number of users that can be supported by the WLAN are 2\n", + "The bandwidth efficiency is 0.15 bps/Hz\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.2, Page 733" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Stepsize=200.; #in Hz\n", + "Chipsmin=20.;#length of linear feedback shift register \n", + "Datarate=1.2*10**3; #bps\n", + "\n", + "#Calculations\n", + "No_of_tones=2**Chipsmin;\n", + "Bss=No_of_tones*Stepsize;\n", + "Chiprate=Datarate*Chipsmin;\n", + "Gp=Bss/Datarate;#processing gain\n", + "Symbolrate=Datarate/3; #8-ary FSK is used\n", + "Chips_symbol=Chiprate/Symbolrate;\n", + "\n", + "#Results\n", + "print 'The Hopping Bandwidth is %.3f MHz'%(Bss/10**6);\n", + "print 'The chiprate is %d kchip/sec'%(Chiprate/10**3);\n", + "print 'Chips per symbol are %d'%(Chips_symbol);\n", + "print 'The processing gain is %.1f'%Gp" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Hopping Bandwidth is 209.715 MHz\n", + "The chiprate is 24 kchip/sec\n", + "Chips per symbol are 60\n", + "The processing gain is 174762.7\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.3, Page 734" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "InfoSc=48.;#Information subcarriers\n", + "SyncSc=4.;#synchronization subcarriers\n", + "ReservedSc=12.;#Reserved subcarriers\n", + "Symrate=250.; #ksps(kilosymbols per second)\n", + "BW=20.; #/in MHz\n", + "Grdt=800.; #Guard time in nsec\n", + "\n", + "#Calculations\n", + "TotalSc=InfoSc+SyncSc+ReservedSc;#Total subcarriers\n", + "BW_Sch=BW*10**6/TotalSc;#BW of subchannel\n", + "Mod_eff=Symrate*10**3/(BW_Sch);#Modulation efficiency\n", + "User_txrate=InfoSc*Symrate*10**3;\n", + "User_bitsymbol=4; #16-QPSK is used\n", + "User_DR=36; #Mbps\n", + "Sym_Dur=1./(Symrate*10**3);\n", + "TimeUti=Sym_Dur/(Sym_Dur+(Grdt/10**9));\n", + "\n", + "#Results\n", + "print 'The bandwidth of subchannel is %.1f kHz'%(BW_Sch/10**3);\n", + "print 'Modulation efficiency is %.1f symbols/sec/Hz'%Mod_eff\n", + "print 'User symbol rate is %d Msps'%(User_txrate/10**6);\n", + "print 'Time Utilization efficiency is %.2f'%TimeUti" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The bandwidth of subchannel is 312.5 kHz\n", + "Modulation efficiency is 0.8 symbols/sec/Hz\n", + "User symbol rate is 12 Msps\n", + "Time Utilization efficiency is 0.83\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.4, Page 735" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Eb_No=10; #in dB\n", + "Noise=-120; #in dBm\n", + "Pt=20; #in mwatt\n", + "R=1; #Data rate in Mbps\n", + "CHBW=0.5; #BW in MHz\n", + "A=37.7; #path loss at the \ufb01rst meter in dB\n", + "Y=3.3; #path loss exponent\n", + "Lf=19; #function relating power loss with number of \ufb02oors n (in dB)\n", + "Ls=10; # lognormally distributed random variable representing the shadow effect in dB \n", + "\n", + "#Calculations\n", + "S2Nreqd=Eb_No*R/CHBW;\n", + "Rx_sensi=Noise+S2Nreqd;\n", + "Lp=10*math.log10(20)-Rx_sensi;\n", + "#Lp=A+10Ylod(d)+Lf+Ls;therefore\n", + "d=10**((Lp-A-Lf-Ls)/(10*Y));\n", + "\n", + "#Result\n", + "print 'The coverage of AP is %.1f metres'%d;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The coverage of AP is 25.3 metres\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.5, Page 758" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "R=3./4;#code rate of convolution encoder\n", + "M1=9.; #payload transmission rate in Mbps for mode 1\n", + "M2=36.; #payload transmission rate in Mbps for mode 2\n", + "\n", + "#Calculations&Results\n", + "D1=M1*10**6/48;#user data rate in kbps for mode 1 \n", + "D2=M2*10**6/48;#user data rate in kbps for mode 2 \n", + "#Refering to Table 21.11\n", + "print 'Data transmission rate per carrier with 3/4 convolution encoder are %.1f Kbps and %d Kbps'%(D1/10**3,D2/10**3);\n", + "C1=D1/R;\n", + "C2=D2/R;\n", + "print 'Carrier transmission rate with R=3/4 convolutional encoder are %d Kbps and %d Kbps'%(C1/10**3,C2/10**3);\n", + "print 'Carrier symbol rate with R=3/4 convolutional encoder are %d ksps and %d Ksps'%(C1/10**3,C2/4/10**3); #Mode1 as BPSK and MOde2 as 16-QAM" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Data transmission rate per carrier with 3/4 convolution encoder are 187.5 Kbps and 750 Kbps\n", + "Carrier transmission rate with R=3/4 convolutional encoder are 250 Kbps and 1000 Kbps\n", + "Carrier symbol rate with R=3/4 convolutional encoder are 250 ksps and 250 Ksps\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.6, Page 759" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "R=3./4; #code rate for convolution encoder\n", + "\n", + "#Calculations\n", + "#64-QAM modulation is used\n", + "Sc=250; #Carrier symbol rate(ksps) from Exa 21.5\n", + "Bits_sym=math.log(64,2); #64-QAM is used\n", + "User_R=Bits_sym*Sc*10**3*R*48;\n", + "\n", + "#Result\n", + "print 'The user data rate is %d Mbps'%(User_R/10**6);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The user data rate is 54 Mbps\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.7, Page 762" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "D=1000.*8; #packet size in bits\n", + "R=2.*10**6; #transmission rate in bps\n", + "L=3.; #msec(Dwell time)\n", + "H=0.625; #msec(Duration of BT packet)\n", + "\n", + "#Calculations\n", + "Tw=10**3*D/R; #the packet duration of IEEE 802.11 in msec\n", + "H_L=1.;\n", + "G=(H_L)*L-Tw-H;\n", + "Gm=abs(G);\n", + "PER_FH=1-((1-Gm/L)*(78./79)**(H_L)+Gm/L*(78./79)**((H_L)-G/Gm));\n", + "PER_DS=1-((1-Gm/L)*(57./79)**(H_L)+Gm/L*(57./79)**((H_L)-G/Gm));\n", + "\n", + "#Results\n", + "print 'The PER for FH packet and PER for DS packet are %d percent & %.2f percent respectively'%(round(PER_FH*100),PER_DS*100);\n", + "print \"The collision probability with 802.11 DS is much higher than with 802.11 FH.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The PER for FH packet and PER for DS packet are 2 percent & 38.73 percent respectively\n", + "The collision probability with 802.11 DS is much higher than with 802.11 FH.\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.8, Page 765" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "d=10; # distance between AP and IEEE 802.11 device in metres\n", + "Y=4; #path loss exponent\n", + "PBt=20; #the transmitted power by the BT in dBm\n", + "PAp=40; #the transmitted power by the AP in dBm\n", + "Pe=10**-5;#acceptable error probability\n", + "\n", + "#Calculations\n", + "#Pe=0.5*e**(-0.5*Eb/No)\n", + "SIR=math.log(Pe/0.5)/(-0.5);# signal-to-interference ratio \n", + "rmax=d*(SIR*PBt/PAp)**(1./Y);# range of interference between Bluetooth and 802.11 device \n", + "\n", + "#Results\n", + "print 'Minimum SIR is %.2f dB = %.1f'%(10*math.log10(SIR),SIR);\n", + "print 'Maximum coverage range is %.2f metres'%rmax;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum SIR is 13.35 dB = 21.6\n", + "Maximum coverage range is 18.14 metres\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.9, Page 765" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "SIRmin=21.6; #From eg 21.8 i.e(13.36 dB)\n", + "d=10; #distance between AP and IEEE 802.11 device in m\n", + "PMs=40; # transmitted power of the IEEE 802.11 device in dBm\n", + "PBt=20; #the transmitted power by the BT in dBm\n", + "Y=4 ; #path loss exponent\n", + "\n", + "#Calculations\n", + "rmax=d*(SIRmin*PMs/PBt)**(1./Y);\n", + "\n", + "#Result\n", + "print 'Maximum coverage range is %.1f metres'%rmax" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum coverage range is 25.6 metres\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21.10, Page 765" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Gp=11;#processing gain(given)\n", + "#Defining variables from Exa 21.8 & 21.9\n", + "PBt=20; # transmitted power by the BT in dBm\n", + "PMs=40; # transmitted power of the IEEE 802.11 device in dBm\n", + "PAp=40; # transmitted power by the AP in dBm\n", + "d=10; # distance between AP and IEEE 802.11 device in m\n", + "Y=4; #path loss exponent\n", + "Pe=10**-5;#Error probability\n", + "\n", + "#Calculations&Results\n", + "#Pe=0.5*e**(-0.5*Eb/No)\n", + "SIR=math.log(Pe/0.5)/(-0.5);\n", + "r1max=d*(SIR*PBt/(PAp*Gp))**(1./Y);# range of interference between Bluetooth and 802.11 device \n", + "print 'Maximum coverage range for IEEE 802.11 DS is %.2f metres'%r1max\n", + "r2max=d*(SIR*PMs/(PBt*Gp))**(1./Y);\n", + "print 'Maximum coverage range for IEEE 802.11 FH is %.2f metres'%r2max;\n", + "print \"Thus, the interference ranges are smaller for the IEEE 802.11 DS device than the IEEE 802.11 FH device.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum coverage range for IEEE 802.11 DS is 9.96 metres\n", + "Maximum coverage range for IEEE 802.11 FH is 14.08 metres\n", + "Thus, the interference ranges are smaller for the IEEE 802.11 DS device than the IEEE 802.11 FH device.\n" + ] + } + ], + "prompt_number": 11 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb new file mode 100755 index 00000000..40f3b8ea --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb @@ -0,0 +1,543 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f32dec82dcc091d4a1d388fd0afce868d4917308e897fe0d3ace9d832db79571" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3: Radio Propagation and Propagation Path-Loss Models" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.1, Page 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "hb=100; #in feets(height of BS antenna)\n", + "hm=5; # in feets(height of mobile antenna)\n", + "f=881.52;#in MHz\n", + "lamda=1.116; #in feet\n", + "d=5000; #in feet\n", + "Gb=10**0.8; #8dB(BS antenna gain)\n", + "Gm=10**0; # 0dB (Mobile antenna gain)\n", + "\n", + "#Calculations&Results\n", + "free_atten=(4*math.pi*d/lamda)**2*(Gb*Gm)**-1;\n", + "y=round(10*math.log10(free_atten));\n", + "print 'Free space attenuation is %d dB \\n'%y\n", + "reflect_atten= (d**4/(hb*hm)**2)*(Gb*Gm)**-1;\n", + "x=round(10*math.log10(reflect_atten));\n", + "print 'Reflecting surface attenuation is %d dB \\n '%x" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Free space attenuation is 87 dB \n", + "\n", + "Reflecting surface attenuation is 86 dB \n", + " \n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.2, Page 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "d=8000; #Distance between base station and mobile station\n", + "f=1.5*10**9;#in Hz \n", + "lamda=0.2; #in metres\n", + "Pt=10; #BS transmitted power in watts\n", + "Lo=8; #Total system losses in dB\n", + "Nf=5; #Mobile receiver noise figure in dB\n", + "T=290; #temperature in degree kelvin\n", + "BW=1.25*10**6; #in Hz\n", + "Gb=8; #in dB\n", + "Gm=0; #in dB\n", + "Hb=30; #in metres\n", + "Hm=3.; #in metres\n", + "B=1.38*10**-23; #Boltzmann's constant\n", + "\n", + "#Calculations&Results\n", + "Free_Lp=20*math.log10(Hm*Hb/d**2);\n", + "Pr=Free_Lp-Lo+Gm+Gb+Pt; #in dBW\n", + "Te=T*(3.162-1);\n", + "Pn=B*(Te+T)*BW;\n", + "print 'Received signal power is %d dBW \\n'%(10*math.log10(Pn))\n", + "SNR=Pr-10*math.log10(Pn);\n", + "print 'SNR ratio is %d dB \\n'%(round(SNR))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Received signal power is -138 dBW \n", + "\n", + "SNR ratio is 31 dB \n", + "\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.3, Page 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "d=3*1000;#in metres\n", + "Y=4;# path loss exponent\n", + "Pt=4; #Transmitted power in watts\n", + "f=1800*10**6;#in Hz\n", + "Shadow=10.5; #in dB\n", + "d0=100.;#in metres\n", + "P0=-32; #in dBm\n", + "\n", + "#Calculations&Results\n", + "print \"Using equation 3.11 and including shadow effect we get\"\n", + "Pr=P0+10*Y*math.log10(d0/d)+Shadow;\n", + "print 'Received power is %.1f dBm \\n'%Pr\n", + "path_loss=10*math.log10(Pt*1000)-Pr;\n", + "print 'Allowable path loss is %.1f dB \\n'%path_loss" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using equation 3.11 and including shadow effect we get\n", + "Received power is -80.6 dBm \n", + "\n", + "Allowable path loss is 116.6 dB \n", + "\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.4, Page 58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "shadow=10.; #in dB\n", + "Lp=150; #in dB\n", + "\n", + "#Calculations&Results\n", + "print \"Using equation given in Problem i.e Lp=133.2+40*math.log(d) we get,\"\n", + "d=10**((Lp-10-133.2)/40);\n", + "print \"Separation between transmitter and receiver as %.2f km\"%d" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using equation given in Problem i.e Lp=133.2+40*math.log(d) we get,\n", + "Separation between transmitter and receiver as 1.48 km\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.5, Page 61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "v=60*0.44704; #.. mph to mps\n", + "fc=860*10**6;#in Hz\n", + "td=2*10**-6; #RMS delay spread in sec\n", + "c=3.*10**8;# speed of light in m/sec\n", + "Rs=19200.; #Coded symbol rate in bps\n", + "\n", + "#Calculations&Results\n", + "lamda=c/fc;\n", + "fm=v/lamda; #Maximum doppler shift\n", + "tc=1/(2*math.pi*fm);#Channel coherence time\n", + "print 'Channel coherence time is %.4f sec \\n'%tc\n", + "ts=1/Rs; #symbol interval\n", + "print 'Symbol interval is %d microsec \\n'%(ts*10**6);\n", + "print \"As the symbol interval is much smaller compared to the channel coherence time. So, Symbol distortion is minimal and fading is slow.\";\n", + "print \"\";\n", + "Bc=1/(2*math.pi*td);\n", + "print 'Coherence Bandwidth is %.2f kHz \\n'%(Bc/1000)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Channel coherence time is 0.0021 sec \n", + "\n", + "Symbol interval is 52 microsec \n", + "\n", + "As the symbol interval is much smaller compared to the channel coherence time. So, Symbol distortion is minimal and fading is slow.\n", + "\n", + "Coherence Bandwidth is 79.58 kHz \n", + "\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.6, Page 65" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "p=1;# re\ufb02ection coef\ufb01cient of ground \n", + "c=3.*10**8;# velocity of light in free space(m/sec)\n", + "e=2.71828;#Euler's number\n", + "fm=20; #in Hz\n", + "fc=900*10**6; #carrier frequency in Hz\n", + "\n", + "#Calculations&Results\n", + "Nr=math.sqrt(2*math.pi)*fm*p*e**-(p**2);\n", + "print 'NO of fades per second are %.2f \\n'%Nr\n", + "Afd=e**-(p**2)/(p*fm*math.sqrt(2*math.pi));\n", + "print 'Average fade duration is %.4f sec \\n '%Afd\n", + "v=fm*c/fc;\n", + "print 'Maximum velocity of mobile is %.2f m/sec = %d Km/hour \\n'%(v,v*18/5);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "NO of fades per second are 18.44 \n", + "\n", + "Average fade duration is 0.0073 sec \n", + " \n", + "Maximum velocity of mobile is 6.67 m/sec = 24 Km/hour \n", + "\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.7, Page 70" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "%matplotlib inline\n", + "\n", + "#Variable declaration\n", + "d=np.array([1, 2, 3, 4, 5]); #in km\n", + "hb=30; #Height of BS antenna in metres\n", + "hm=2;# height of mobile antenna in matres\n", + "fc=900;#carrier frequency in MHz\n", + "W=15; #street width(m)\n", + "b=30; # distance between building along radio path (m) \n", + "phi=90; # incident angle relative to the street\n", + "hr=30; #in m\n", + "\n", + "#Calculations\n", + "dellhm=hr-hm;\n", + "#L50=Lf+Lrts+Lms\n", + "\n", + "# By COST 231 model\n", + "Lf=32.4+20*np.log10(d)+20*np.log10(fc);\n", + "L0=4-0.114*(phi-55);\n", + "Lrts=-16.9-10*math.log10(W)+10*math.log10(fc)+20*math.log10(dellhm)+L0;\n", + "Lbsh=-18*math.log10(11);\n", + "ka=54-0.8*hb;\n", + "dellhb=hb-hr;\n", + "kd=18-15*dellhb/dellhm;\n", + "kf=4+0.7*(fc/925-1);\n", + "Lms=Lbsh+ka+kd*np.log10(d)+kf*np.log10(fc)-9*np.log10(b);\n", + "L50=np.array([0, 0, 0, 0, 0])\n", + "L50=Lf+Lrts+Lms;\n", + "\n", + "#Okumura/Hata model\n", + "ahm=(1.1*math.log10(fc)-0.7)*hm-(1.56*math.log10(fc)-0.8);\n", + "L_50=69.55+26.16*np.log10(fc)+(44.9-6.55*np.log10(hb))*np.log10(d)-13.82*np.log10(hb)-ahm;\n", + "L_50 = np.array(L_50)\n", + "\n", + "#Results\n", + "fig,ax1 = plt.subplots()\n", + "ax1.plot(d,L_50,'b-')\n", + "ax1.set_xlabel('Distance from transmitter(in km)')\n", + "ax1.set_ylabel('Path loss (in dB)')\n", + "ax2 = ax1.twinx()\n", + "ax2.plot(d,L50,'r')\n", + "ax1.legend(['COST 231 model'],loc=0)\n", + "ax2.legend(['HATA model'],loc=0)\n", + "ax1.grid()\n", + "plt.show()\n", + "print \"L50 values by Cost 231 model\"\n", + "print '%.2f %.2f %.2f %.2f %.2f \\n '%(L50[0],L50[1],L50[2],L50[3],L50[4]);\n", + "print \"L50 values bu Okumura/Hata model\"\n", + "print '%.2f %.2f %.2f %.2f %.2f \\n '%(L_50[0],L_50[1],L_50[2],L_50[3],L_50[4]);\n", + "print \"The results from the plot of two models shows that the calculated path loss with the COST 231 model is higher than the value obtained by the Okumura/Hata model.\"\n", + "\n", + "#Answers vary due to built-in functions of Python used" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEPCAYAAABhkeIdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKIqiKIqiKIqiZEz+H0C1ZRMhMDC/AAAAAElFTkSuQmCC\n", + "text": [ + "<matplotlib.figure.Figure at 0xb55925ac>" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "L50 values by Cost 231 model\n", + "129.03 140.47 147.16 151.91 155.59 \n", + " \n", + "L50 values bu Okumura/Hata model\n", + "125.13 135.73 141.93 146.34 149.75 \n", + " \n", + "The results from the plot of two models shows that the calculated path loss with the COST 231 model is higher than the value obtained by the Okumura/Hata model.\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.8, Page 76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "SNRmin=12;#in dB\n", + "n=3; #No of floors\n", + "Backgroundnoise=-115; #dBm\n", + "pt=100 #in dBm\n", + "\n", + "#Calculations\n", + "pt_db=10*math.log10(pt);\n", + "Sr=Backgroundnoise+SNRmin; #receiver sensitivity\n", + "Lpmax=pt_db-Sr;\n", + "#Refering table 3.4\n", + "Lp_d0=38; #ref path loss at the first meter(dB)\n", + "Lf=15+4*(n-1); #signal attenuation through n floors\n", + "y=3; #path loss exponent\n", + "X=10; #Shadowing effect(dB)\n", + "d=10**((Lpmax-Lp_d0-Lf-X)/30); #max allowable path loss\n", + "\n", + "#Result\n", + "print 'Coverage radius of an access point = %d m \\n'%(round(d))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Coverage radius of an access point = 54 m \n", + "\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.9, Page 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "SSmean=-100; #signal strength(dBm)\n", + "Sr=-110; #receiver sensitivity(dBm)\n", + "sd=10; #standard deviation(dB)\n", + "\n", + "#Calculations\n", + "P_Smin=(0.5-0.5*math.erf((Sr-SSmean)/(math.sqrt(2)*sd)));\n", + "\n", + "#Result\n", + "print 'probability of exceeding signal beyond the receiver sensitivity is %.2f \\n'%(P_Smin)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "probability of exceeding signal beyond the receiver sensitivity is 0.84 \n", + "\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.10, Page 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Lp=140; # path losses in dB \n", + "k=1.38*10**-23; # Boltzmann\u2019s constant (W/Kelvin-Hz)\n", + "k_db=10*math.log10(k);\n", + "f=900;#in MHz\n", + "Gt=8; #transmitting antenna gain(dB)\n", + "Gr=0; #receiver antenna gain(dB)\n", + "Ag=24;#gain of receiver ampli\ufb01er in dB \n", + "Fmargin=8;#Fade margin(dB)\n", + "Nf=6;#Noise figure(dB)\n", + "L0=20; #\u0002 other losses in dB\n", + "Lf=12; # antenna feed line loss in dB \n", + "T=24.6;#Temperature expressed in dB\n", + "R=39.8; #\u0002 data rate in dB \n", + "M=8; #overall link margin(dB)\n", + "Eb_No=10;#dB\n", + "\n", + "#Calculations\n", + "#From equation (3.54)\n", + "pt_db=M-Gt-Gr-Ag+ Nf + T+ k_db+ Lp+ Lf+ L0 + Fmargin+ R+ Eb_No;\n", + "\n", + "Pt=10**(pt_db/10); #dB into normal number\n", + "\n", + "#Result\n", + "print 'Total transmitted power is %d Watts \\n'%Pt" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total transmitted power is 6 Watts \n", + "\n" + ] + } + ], + "prompt_number": 25 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb new file mode 100755 index 00000000..6a6cd416 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb @@ -0,0 +1,338 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:d1cbcab673c40d252caf601352e39b3f6fb5df10eada02ad15211795afd1b59f" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4: An Overview of Digital Communication and Transmission" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1, Page 93" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Fm=20; # in KHz\n", + "\n", + "#Calculations\n", + "print \"An Engineering version of the Nyquist sampling rate : fs>=2.2*fm.\"\n", + "print 'Therefore sampling rate of >= %d ksps should be used '%(2.2*Fm); \n", + "print \"The sampling rate for a compact disc digital audio player = 44.1 ksps and for a studio quality audio player = 48 ksps are used.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "An Engineering version of the Nyquist sampling rate : fs>=2.2*fm.\n", + "Therefore sampling rate of >= 44 ksps should be used \n", + "The sampling rate for a compact disc digital audio player = 44.1 ksps and for a studio quality audio player = 48 ksps are used.\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2, Page 96" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Rt=1; #Resistance(ohm)\n", + "#L= Number of quantization values\n", + "L1=32;\n", + "L2=64;\n", + "L3=128;\n", + "L4=256;\n", + "\n", + "#Calculations\n", + "# L=2**R i.e R=math.log2(L);\n", + "R1=math.log(L1,2);\n", + "R2=math.log(L2,2);\n", + "R3=math.log(L3,2);\n", + "R4=math.log(L4,2);\n", + "\n", + "#P=A**2/2; #average power of signal\n", + "#sig**2=0.333*A**2*2**(-2*Rt); #Avg quantization noise power\n", + "#SNR=P/sig**2;\n", + "# SNR(dB)=1.8+ 6R;\n", + "\n", + "SNR1=1.8+6*R1;\n", + "SNR2=1.8+6*R2;\n", + "SNR3=1.8+6*R3;\n", + "SNR4=1.8+6*R4;\n", + "\n", + "#Result\n", + "print 'For L=32, SNR is %.1f dB\\n '%SNR1\n", + "print 'For L=64, SNR is %.1f dB\\n '%SNR2\n", + "print 'For L=128, SNR is %.1f dB\\n '%SNR3\n", + "print 'For L=256, SNR is %.1f dB\\n '%SNR4" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For L=32, SNR is 31.8 dB\n", + " \n", + "For L=64, SNR is 37.8 dB\n", + " \n", + "For L=128, SNR is 43.8 dB\n", + " \n", + "For L=256, SNR is 49.8 dB\n", + " \n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3, Page 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Fs=8*10**3; #in Hz\n", + "Fm=3.4*10**3; # in Hz\n", + "VCH=24; #voice channels\n", + "SCH=1; #sunchronization channel\n", + "PDur=1; #extra pulse duration in microsec\n", + "\n", + "#Calculations&Results\n", + "Ts=1/(Fs);\n", + "TimeCH=Ts/(VCH+SCH)*10**6; # in microsec\n", + "print 'Time between the pulses is %d microsec\\n'%(TimeCH-PDur);\n", + "#Now by using the engineering version of Nyquist rate sampling\n", + "NyquistRate=2.2*Fm;\n", + "Ts1_microsec=1/NyquistRate*10**6;\n", + "Tc=round(Ts1_microsec)/(VCH+SCH);\n", + "print \"Time between the pulses by using engineering version of Nyquist rate sampling is %.2f microsec\\n\"%(Tc-PDur);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time between the pulses is -1 microsec\n", + "\n", + "Time between the pulses by using engineering version of Nyquist rate sampling is 4.36 microsec\n", + "\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4, Page 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Fm=3000; #highest modulating frequency in signal(Hz)\n", + "M=32; # number of pulse levels \n", + "b=5; #bits per symbol \n", + "p=0.01; #Quantization distortion\n", + "\n", + "#Calculations\n", + "#2**R = L >= 1/2P\n", + "# where R is the number of bits required to represent quantization levels L\n", + "R=math.log10(1./(2*p))/math.log10(2);\n", + "Fs=2*Fm; # Nyquist sampling criteria (samples per second)\n", + "fs=round(R)*Fs;\n", + "Rs=fs/b;\n", + "\n", + "#Result\n", + "print 'The minimum number of bits/sample or bits/PCM word that should be used are %d'%(round(R));\n", + "print 'The minimum sampling rate is %d samples per second\\n '%Fs;\n", + "print 'The resulting transmission rate is %d bps\\n '%fs;\n", + "print 'The PCM pulse or symbol transmission rate is %d symbols/sec\\n'%Rs" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The minimum number of bits/sample or bits/PCM word that should be used are 6\n", + "The minimum sampling rate is 6000 samples per second\n", + " \n", + "The resulting transmission rate is 36000 bps\n", + " \n", + "The PCM pulse or symbol transmission rate is 7200 symbols/sec\n", + "\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5, Page 110" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "S_No=53.; #dB-Hz\n", + "R=9.6*10**3; #bps\n", + "BW=4.8*10**3; #Khz\n", + "Pb=10**-5; #BER<=10**-5;\n", + "\n", + "#Calculations\n", + "print \"Since the required data rate of 9.6 kbps is more than the available bandwidth of 4.8 kHz, the channel is bandwidth-limited.\"\n", + "Eb_No=S_No-10*math.log10(R); #dB\n", + "# Try for 8-PSK modulation scheme\n", + "M=8;\n", + "Ps=math.log(M,2)*Pb; #Max ps\n", + "Es_No=math.log(M,2)*10**(0.1*Eb_No);\n", + "#Ps(8)=2*Q(math.sqrt(2*Es_No)*sin(math.pi/8));\n", + "#2*Q(math.sqrt(2*Eb_No))=erfc(math.sqrt(Eb_No)); #Refer EQn C(7) from appendix C\n", + "\n", + "Ps8=math.erfc(math.sqrt(Es_No)*math.sin(math.pi/8));\n", + "\n", + "#Result\n", + "print 'Symbol error rate is given as %.5f \\n '%Ps\n", + "print 'The ratio of signal energy to noise is %.2f \\n '%Es_No;\n", + "print 'Symbol error rate for 8-PSK is %.5f \\n '%Ps8;\n", + "print \"As symbol error rate for 8-PSK modulation is lower than threshold value. so, We can use 8-PSK modulation.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Since the required data rate of 9.6 kbps is more than the available bandwidth of 4.8 kHz, the channel is bandwidth-limited.\n", + "Symbol error rate is given as 0.00003 \n", + " \n", + "The ratio of signal energy to noise is 62.35 \n", + " \n", + "Symbol error rate for 8-PSK is 0.00002 \n", + " \n", + "As symbol error rate for 8-PSK modulation is lower than threshold value. so, We can use 8-PSK modulation.\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.6, Page 111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "SNR=48.; #dB-Hz\n", + "BW=45.*10**3; #in Hz\n", + "R=9.6*10**3; #bps\n", + "Pb=10**-5; #Bit error rate\n", + "e=2.71828; #Natural exponent e\n", + "\n", + "#Calculations&Results\n", + "print \"since the available bandwidth of 45 kHz is more than adequate to support the required data rate of 9.6 kbps.\";\n", + "print \"So, the channel is not bandwidth limited \";\n", + "Eb_No=SNR-10*math.log10(R);\n", + "#We try the 16-FSK modulation scheme\n", + "M=16;\n", + "\n", + "Es_No=math.log(M,2)*Eb_No;\n", + "Ps=(M-1)/2*e**(-Es_No/2);\n", + "#For orthogonal signalling\n", + "Ps16=(2**M-1)/(2**(M-1))*Pb;\n", + "print \"\"\n", + "print 'The maximum symbol error probability is %0.5f \\n '%Ps16\n", + "print 'The symbol error probability achieved by 16-PSK is %.9f \\n '%Ps;\n", + "print \"As achieved symbol error probability is far less than maximum tolerable value\";\n", + "print \"So, we can meet the given speci\ufb01cations for this power-limited channel with a 16-FSK modulation scheme without any error-correction coding\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "since the available bandwidth of 45 kHz is more than adequate to support the required data rate of 9.6 kbps.\n", + "So, the channel is not bandwidth limited \n", + "\n", + "The maximum symbol error probability is 0.00001 \n", + " \n", + "The symbol error probability achieved by 16-PSK is 0.000000553 \n", + " \n", + "As achieved symbol error probability is far less than maximum tolerable value\n", + "So, we can meet the given speci\ufb01cations for this power-limited channel with a 16-FSK modulation scheme without any error-correction coding\n" + ] + } + ], + "prompt_number": 15 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb new file mode 100755 index 00000000..153ee7fb --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb @@ -0,0 +1,416 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:98db718d0bf89da2e915ec31624499d68101b659175b122291fbf41d86cde068" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5: Fundamentals of Cellular Communications" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.1, Page 130" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "ToCH=960.;# Total available channels\n", + "Cellarea=6.; #in km^2\n", + "Covarea=2000.;#in km^2\n", + "N1=4.; # Cluster Size\n", + "N2=7.; #Cluster Size\n", + "\n", + "#Calculations\n", + "Area1=N1*Cellarea;#for N=4\n", + "Area2=N2*Cellarea;#For N=7\n", + "No_of_clusters1=round(Covarea/Area1);\n", + "No_of_clusters2=round(Covarea/Area2);\n", + "No_of_CH1=ToCH/N1; # No of channels with cluster size 4\n", + "No_of_CH2=ToCH/N2; # No of channels with cluster size 7\n", + "SysCap1=No_of_clusters1*ToCH;\n", + "SysCap2=No_of_clusters2*ToCH;\n", + "\n", + "#Results\n", + "print 'System Capacity with cluster size 4 is %d channels'%SysCap1\n", + "print 'Number of clusters for covering total area with N equals 4 are %d'%No_of_clusters1\n", + "print 'System Capacity with cluster size 7 is %d channels'%SysCap2\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "System Capacity with cluster size 4 is 79680 channels\n", + "Number of clusters for covering total area with N equals 4 are 83\n", + "System Capacity with cluster size 7 is 46080 channels\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.2, Page 132" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "S_IAMP=18.;# S/I ratio in dB\n", + "S_IGSM=12.;# S/I ratio in dB\n", + "PPL=4.; # propogation path loss coefficient\n", + "\n", + "#Calculations\n", + "# Using Equation 5.16 on page no 132, we get\n", + "N_AMP=(1./3)*((6*10**(0.1*S_IAMP))**(2/PPL));#reuse factor for AMPS\n", + " \n", + "N_GSM=(1./3)*((6*10**(0.1*S_IGSM))**(2/PPL));#reuse factor for GSM\n", + "\n", + "\n", + "#Result\n", + "print 'Reuse Factor for AMP system is N = %.3f = approx %d \\n'%(N_AMP,N_AMP+1);\n", + "print 'Reuse Factor for GSM system is N = %.3f = approx %d \\n'%(N_GSM,N_GSM+1);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reuse Factor for AMP system is N = 6.486 = approx 7 \n", + "\n", + "Reuse Factor for GSM system is N = 3.251 = approx 4 \n", + "\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.3, Page 132" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "VCH=395.;#Total voice channels\n", + "CallHT=120.;#average call holding time in sec\n", + "Blocking=0.02;# 2%\n", + "PPL=4.; #propogation path loss coefficient\n", + "N1=4. #reuse factor\n", + "N2=7.; #reuse factor\n", + "N3=12.; #reuse factor\n", + "\n", + "#Calculations&Results\n", + "No_of_VCH1=VCH/N1; #for reuse factor N1\n", + "No_of_VCH2=VCH/N2; #for reuse factor N2\n", + "No_of_VCH3=VCH/N3; #for reuse factor N3\n", + "print 'NO of voice channels for N=4 are %d'%(round(No_of_VCH1));\n", + "print 'NO of voice channels for N=7 are %d'%(round(No_of_VCH2));\n", + "print 'NO of voice channels for N=12 are %d\\n'%(round(No_of_VCH3));\n", + "TrafLoad1=87.004;\n", + "Carryload1=(1-Blocking)*TrafLoad1;\n", + "TrafLoad2=45.877;\n", + "Carryload2=(1-Blocking)*TrafLoad2;\n", + "TrafLoad3=24.629;\n", + "Carryload3=(1-Blocking)*TrafLoad3;\n", + "# To find cell capacity\n", + "Ncall1=Carryload1*3600/CallHT;#Calls per hour per cell \n", + "Ncall2=Carryload2*3600/CallHT;\n", + "Ncall3=Carryload3*3600/CallHT;\n", + "print 'calls per hour per cell for N=4 are %d'%(round(Ncall1));\n", + "print 'calls per hour per cell for N=7 are %d'%(round(Ncall2));\n", + "print 'calls per hour per cell for N=12 are %d \\n'%(Ncall3);\n", + "# To find S BY I\n", + "# N=(1/3)[6*(S/I)]**(2/PPL)\n", + "S_I1=10*(PPL/2)*(math.log10(N1)-math.log10(1./3)-(2./PPL)*math.log10(6));#Mean S/I (dB)\n", + "\n", + "S_I2=10*(PPL/2)*(math.log10(N2)-math.log10(1./3)-(2./PPL)*math.log10(6));\n", + "S_I3=10*(PPL/2)*(math.log10(N3)-math.log10(1./3)-(2./PPL)*math.log10(6));\n", + "\n", + "print 'Mean S/I(dB) for N=4 is %.1f'%S_I1\n", + "print 'Mean S/I(dB) for N=7 is %.1f'%S_I2\n", + "print 'Mean S/I(dB) for N=12 is %.1f'%S_I3" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "NO of voice channels for N=4 are 99\n", + "NO of voice channels for N=7 are 56\n", + "NO of voice channels for N=12 are 33\n", + "\n", + "calls per hour per cell for N=4 are 2558\n", + "calls per hour per cell for N=7 are 1349\n", + "calls per hour per cell for N=12 are 724 \n", + "\n", + "Mean S/I(dB) for N=4 is 13.8\n", + "Mean S/I(dB) for N=7 is 18.7\n", + "Mean S/I(dB) for N=12 is 23.3\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.4, Page 154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "spectrum=12.5*10**6; #in Hz\n", + "CHBW=200*10**3;#in Hz\n", + "N=4.;#reuse factor\n", + "Blocking=0.02; # 2%\n", + "callHT=120.;#average call holding time in sec\n", + "PPL=4.;#propogation path loss coefficient\n", + "CntrlCH=3.; #No of control channels\n", + "Ts=8.; # No of voice channels per RF channel\n", + "\n", + "#Calculations&Results\n", + "No_ofVCH=((spectrum*Ts)/(CHBW*N))-CntrlCH;\n", + "print 'No of voice channels for N=4 are %d'%(No_ofVCH)\n", + "TrafLoad=110.;\n", + "CarryLoad=(1-Blocking)*TrafLoad;\n", + "Ncall=CarryLoad*3600/callHT;\n", + "print 'Calls per hour per cell for N=4 are %d calls/hour/cell \\n '%(round(Ncall));\n", + "S_I=10*(PPL/2)*(math.log10(N)-math.log10(1./3)-(2./PPL)*math.log10(6));\n", + "print 'Mean S/I(dB) for N=4 is %.1f dB \\n '%(S_I)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No of voice channels for N=4 are 122\n", + "Calls per hour per cell for N=4 are 3234 calls/hour/cell \n", + " \n", + "Mean S/I(dB) for N=4 is 13.8 dB \n", + " \n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.5, Page 139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "VCH=395.;#Total allocated voice channels\n", + "CHBW=30.; # in kHz\n", + "Spectrum=12.5; # in MHz\n", + "CallHT=120.; #Average call holding time in sec\n", + "Blocking=0.02; # 2%\n", + "PL=40.; #slope of path loss in dBperdecade\n", + "\n", + "#Calculations&Results\n", + "print \"We consider only the \ufb01rst tier interferers and neglect the effects of cochannel interference from the second and other higher tiers.\"\n", + "#FOR 120degree sectorization\n", + "#N=4\n", + "VCH11=(VCH/(4*3));\n", + "OffLoad11=24.629; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site11=3*OffLoad11;\n", + "CarLoad11=(1-Blocking)*Load_site11;\n", + "Calls_hr_site11=CarLoad11*3600/CallHT;\n", + "R11=math.sqrt(CarLoad11/0.52);\n", + "Seff11=CarLoad11/(2.6*Spectrum*R11**2);\n", + "S_I11=PL*math.log10(math.sqrt(3*4))-10*math.log10(2);\n", + "#N=7\n", + "VCH12=(VCH/(3*7));\n", + "OffLoad12=12.341; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site12=3*OffLoad12;\n", + "CarLoad12=(1-Blocking)*Load_site12;\n", + "Calls_hr_site12=CarLoad12*3600/CallHT;\n", + "R12=math.sqrt(CarLoad12/0.52);\n", + "Seff12=CarLoad12/(2.6*Spectrum*R12**2);\n", + "S_I12=PL*math.log10(math.sqrt(3*7))-10*math.log10(2);\n", + "#N=12\n", + "VCH13=VCH/(3*12);\n", + "OffLoad13=5.842; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site13=3*OffLoad13;\n", + "CarLoad13=(1-Blocking)*Load_site13;\n", + "Calls_hr_site13=CarLoad13*3600/CallHT;\n", + "R13=math.sqrt(CarLoad13/0.52);\n", + "Seff13=CarLoad13/(2.6*Spectrum*R13**2);\n", + "S_I13=PL*math.log10(math.sqrt(3*12))-10*math.log10(2);\n", + "#For omnidirectional \n", + "#N=4\n", + "VCH21=VCH/(4);\n", + "OffLoad21=87.004; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site21=OffLoad21;\n", + "CarLoad21=(1-Blocking)*Load_site21;\n", + "Calls_hr_site21=CarLoad21*3600/CallHT;\n", + "R21=math.sqrt(CarLoad21/0.52);\n", + "Seff21=CarLoad21/(2.6*Spectrum*R21**2);\n", + "S_I21=PL*math.log10(math.sqrt(3*4))-10*math.log10(6);\n", + "#N=7\n", + "VCH22=VCH/(7);\n", + "OffLoad22=46.817; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site22=OffLoad22;\n", + "CarLoad22=(1-Blocking)*Load_site22;\n", + "Calls_hr_site22=CarLoad22*3600/CallHT;\n", + "R22=math.sqrt(CarLoad22/0.52);\n", + "Seff22=CarLoad22/(2.6*Spectrum*R22**2);\n", + "S_I22=PL*math.log10(math.sqrt(3*7))-10*math.log10(6);\n", + "#N=12\n", + "VCH23=VCH/(12);\n", + "OffLoad23=24.629; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site23=OffLoad23;\n", + "CarLoad23=(1-Blocking)*Load_site23;\n", + "Calls_hr_site23=CarLoad23*3600/CallHT;\n", + "R23=math.sqrt(CarLoad23/0.52);\n", + "Seff23=CarLoad23/(2.6*Spectrum*R23**2);\n", + "S_I23=PL*math.log10(math.sqrt(3*12))-10*math.log10(6);\n", + "# For 60degree Sectorization\n", + "#N=3\n", + "VCH31=VCH/(6*3);\n", + "OffLoad31=14.902; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site31=6*OffLoad31;\n", + "CarLoad31=(1-Blocking)*Load_site31;\n", + "Calls_hr_site31=CarLoad31*3600/CallHT;\n", + "R31=math.sqrt(CarLoad31/0.52);\n", + "Seff31=CarLoad31/(2.6*Spectrum*R31**2);\n", + "S_I31=PL*math.log10(math.sqrt(3*3))-10*math.log10(1);\n", + "#N=4\n", + "VCH32=VCH/(6*4);\n", + "OffLoad32=10.656; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site32=6*OffLoad32;\n", + "CarLoad32=(1-Blocking)*Load_site32;\n", + "Calls_hr_site32=CarLoad32*3600/CallHT;\n", + "R32=math.sqrt(CarLoad32/0.52);\n", + "Seff32=CarLoad32/(2.6*Spectrum*R32**2);\n", + "S_I32=PL*math.log10(math.sqrt(3*4))-10*math.log10(1);\n", + "#N=7\n", + "VCH33=VCH/(6*7);\n", + "OffLoad33=5.084; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site33=6*OffLoad33;\n", + "CarLoad33=(1-Blocking)*Load_site33;\n", + "Calls_hr_site33=CarLoad33*3600/CallHT;\n", + "R33=math.sqrt(CarLoad33/0.52);\n", + "Seff33=CarLoad33/(2.6*Spectrum*R33**2);\n", + "S_I33=PL*math.log10(math.sqrt(3*7))-10*math.log10(1);\n", + "#N=12\n", + "VCH34=VCH/(6*12);\n", + "OffLoad34=2.227; # Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n", + "Load_site34=6*OffLoad34;\n", + "CarLoad34=(1-Blocking)*Load_site34;\n", + "Calls_hr_site34=CarLoad34*3600/CallHT;\n", + "R34=math.sqrt(CarLoad34/0.52);\n", + "Seff34=CarLoad34/(2.6*Spectrum*R34**2);\n", + "S_I34=PL*math.log10(math.sqrt(3.*12))-10*math.log10(1);\n", + "\n", + "print 'For Omnidirectional Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency'\n", + "print 'For N=4 %d %.1f %.3f\\n'%(Calls_hr_site21,S_I21,Seff21);\n", + "print 'For N=7 %d %.1f %.3f\\n'%(Calls_hr_site22,S_I22,Seff22);\n", + "print 'For N=12 %d %.1f %.3f\\n'%(Calls_hr_site23,S_I23,Seff23);\n", + "\n", + "print 'For 120deg sector Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency\\n'\n", + "print 'For N=4 %d %.1f %.3f\\n'%(Calls_hr_site11,S_I11,Seff11);\n", + "print 'For N=7 %d %.1f %.3f\\n'%(Calls_hr_site12,S_I12,Seff12);\n", + "print 'For N=12 %d %.1f %.3f\\n'%(Calls_hr_site13,S_I13,Seff13);\n", + "\n", + "print 'For 60 deg Sector Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency\\n'\n", + "print 'For N=3 %d %.1f %.3f\\n'%(Calls_hr_site31,S_I31,Seff31);\n", + "print 'For N=4 %d %.1f %.3f\\n'%(Calls_hr_site32,S_I32,Seff32);\n", + "print 'For N=7 %d %.1f %.3f\\n'%(Calls_hr_site33,S_I33,Seff33);\n", + "print 'For N=12 %d %.1f %.3f\\n'%(Calls_hr_site34,S_I34,Seff34);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "We consider only the \ufb01rst tier interferers and neglect the effects of cochannel interference from the second and other higher tiers.\n", + "For Omnidirectional Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency\n", + "For N=4 2557 13.8 0.016\n", + "\n", + "For N=7 1376 18.7 0.016\n", + "\n", + "For N=12 724 23.3 0.016\n", + "\n", + "For 120deg sector Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency\n", + "\n", + "For N=4 2172 18.6 0.016\n", + "\n", + "For N=7 1088 23.4 0.016\n", + "\n", + "For N=12 515 28.1 0.016\n", + "\n", + "For 60 deg Sector Calls_per_hour_per_cellsite Mean S_I ratio SpecrtalEfficiency\n", + "\n", + "For N=3 2628 19.1 0.016\n", + "\n", + "For N=4 1879 21.6 0.016\n", + "\n", + "For N=7 896 26.4 0.016\n", + "\n", + "For N=12 392 31.1 0.016\n", + "\n" + ] + } + ], + "prompt_number": 22 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb new file mode 100755 index 00000000..7c64b872 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb @@ -0,0 +1,466 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:0b8e52617510df277ef1e48e119f37ff192613df767b6d3b9de6242855aa9cf9" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 6: Multiple Access Techniques" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.1, Page 158" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Area=8; #in km^2\n", + "Cover=4000.;# in km^2\n", + "CallBH=1.2; #Avg calls during BH\n", + "HT=100; # Avg holding time in sec\n", + "Block=0.02; #Blocking=2%\n", + "N=4.;#Frequency reuse factor\n", + "Spectrum=12.5;# in MHz\n", + "CHBW=200;# in kHz\n", + "User_CH=8;#No of users per RF channel\n", + "\n", + "#Calculations&Results\n", + "RFCH=Spectrum*1000/CHBW;\n", + "TCH=int(RFCH)*User_CH;\n", + "SigCH=3;#No of signalling channels per cell\n", + "TCH_cell=TCH/N-SigCH;\n", + "Cells=Cover/Area;\n", + "OffLoad=108.4; # in Erlangs\n", + "print 'Using Erlang-B Tables, Total traffic offered by %d channels at 0.02 blocking = %.1f Erlangs/cell'%(TCH_cell,OffLoad*(1-Block));\n", + "CarLoad=OffLoad*(1-Block);\n", + "Calls_hr_cell=CarLoad*3600/HT;\n", + "MaxUser_hr_cell=Calls_hr_cell/CallBH;\n", + "Seff=CarLoad*Cells/(Spectrum*Cover);\n", + "print 'Spectral Efficiency is %.2f Erlangs/MHz/km^2'%Seff;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using Erlang-B Tables, Total traffic offered by 121 channels at 0.02 blocking = 106.2 Erlangs/cell\n", + "Spectral Efficiency is 1.06 Erlangs/MHz/km^2\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.2, Page 159" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "TCH=395; # Traffic Channels\n", + "SysBW=12.5; #in MHz\n", + "CHspace=30.; # in kHz\n", + "\n", + "#Calculations\n", + "Eff=TCH*CHspace/(SysBW*1000);\n", + "\n", + "#Result\n", + "print 'Multiple access spectral efficiency of FDMA System is %.3f'%Eff" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Multiple access spectral efficiency of FDMA System is 0.948\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.3, Page 160" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Tf=40; #Frame duration in msec\n", + "Mt=6; # Frames per slot\n", + "Bu=30; #bandwidth(KHz) of an individual user during his or her time slot\n", + "Nu=395.;# number of users sharing the same time slot in the system, but having access to different frequency sub-bands\n", + "Bw=12.5; # in MHz\n", + "DR=16.2;#Data rate in kbps\n", + "FDur=40.; # Frame duration in msec\n", + "slots=6; #No of slots per time frame\n", + "IndiRate=16.2; #Individual data rate in kbps\n", + "Srate=13.; #Speech rate in kbps\n", + "\n", + "#Calculations\n", + "TimeSlot=(Srate/IndiRate)*(FDur/slots);\n", + "Seff=TimeSlot*slots*Bu*Nu/(FDur*Bw*1000);\n", + "\n", + "#Results\n", + "print 'Multiple access spectral efficiency of TDMA is %.2f'%Seff;\n", + "print 'The overhead portion of the frame is %d percent'%((1-Seff)*100);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Multiple access spectral efficiency of TDMA is 0.76\n", + "The overhead portion of the frame is 23 percent\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.4, Page 161" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "nb=0.9; #BW efficiency factor\n", + "u=2; # Bit Efficiency with QPSK\n", + "Vf=1; # Voice activity factor\n", + "BW=12.5; #in MHz\n", + "IR=16.2; # in kbps\n", + "N=19; #frequency reuse factor\n", + "\n", + "#Calculations\n", + "Nu=nb*u*BW*1000/(Vf*IR*N);# number of channels (mobile users) per cell\n", + "Seff=int(Nu)*IR/(BW*1000);\n", + "\n", + "#Results\n", + "print 'Capacity of system is %d mobile users per cell'%Nu;\n", + "print 'Spectral efficiency of TDMA system is %.3f bit/sec/Hz'%Seff" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacity of system is 73 mobile users per cell\n", + "Spectral efficiency of TDMA system is 0.095 bit/sec/Hz\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.5, Page 163" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Nr=2.;# number of reference bursts per frame\n", + "Nt=24; # number of traf\ufb01c bursts (slots) per frame(120msec)\n", + "FL=120; #Frame length in msec\n", + "Br=148; # number of overhead bits per reference burst\n", + "Bp=34; # number of overhead bits per preamble per slot \n", + "Bg=8.25;#number of equivalent bits in each guard time interval \n", + "Tf=120; # frame duration in msec\n", + "Rrf=270.83333333; # bit rate of the RF channel in kbps\n", + "R=22.8; #bit rate of each channel in kbps\n", + "\n", + "#Calculations\n", + "B0=Nr*(8*Br)+Nt*(8*Bp)+(Nt+Nr)*(8*Bg);#The number of overhead bits per frame\n", + "Bt=FL*10**-3*Rrf*10**3;#The total number of bits per frame \n", + "Eff=(1-B0/Bt)*100;\n", + "CH_Frame=(Eff/100)*Rrf/R;#No of channels/frame\n", + "\n", + "#Results\n", + "print 'The frame efficiency is %.2f percent'%Eff;\n", + "print 'Number of channels/frame are %d'%(CH_Frame)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The frame efficiency is 67.35 percent\n", + "Number of channels/frame are 7\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.6, Page 170" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "nb=0.9;#bandwidth ef\ufb01ciency\n", + "nf=0.45;#frequency reuse ef\ufb01ciency \n", + "Cd=0.8; #capacity degradation factor \n", + "Vf=0.4;#voice activity factor \n", + "Eb_I0=7; # desired energy-to-interference ratio in dB\n", + "L=1;# ef\ufb01ciency of sector-antenna in cell \n", + "BW=12.5;#One way system BW in MHz\n", + "R=16.2;#Information rate in kbps\n", + "\n", + "#Calculations\n", + "Eb_I=10**(Eb_I0*0.1);#To convert from dB to a normal value\n", + "Nu=(nf*nb*Cd*L/Vf)*(BW*1000/(Eb_I*R));#Capacity of system\n", + "Seff=round(Nu)*R/(12.5*10**3);\n", + "\n", + "#Results\n", + "print 'Capacity of system is %d mobile users per cell'%round(Nu);\n", + "print 'Spectral efficiency of TDMA system is %.3f bits/sec/Hz'%Seff;\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacity of system is 125 mobile users per cell\n", + "Spectral efficiency of TDMA system is 0.162 bits/sec/Hz\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.7, Page 171" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "#Given Data from Exa 6.4 and Exa 6.6\n", + "Cd=0.8; #capacity degradation factor\n", + "R=16.2;#Data rate in kbps\n", + "Eb_I0=7; #in dB\n", + "Eb_I=10**(Eb_I0*0.1);#To convert from dB to a normal value\n", + "Vf=0.4;#voice activity factor \n", + "u=2; # Bit Efficiency\n", + "IR=16.2; # in kbps\n", + "N=19; #frequency reuse factor\n", + "nf=0.45;#frequency reuse ef\ufb01ciency \n", + "\n", + "#Calculations\n", + "Ncdma_by_Ntdma=Cd*N*nf*IR/(Eb_I*Vf*u*R);\n", + "\n", + "#Result\n", + "print 'The ratio of capacity of DS-CDMA to TDMA is %.3f'%Ncdma_by_Ntdma" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The ratio of capacity of DS-CDMA to TDMA is 1.706\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.8, Page 172" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Bss=600; #Hopping bandwidth in MHz\n", + "stepsize=400; # in Hz\n", + "\n", + "#Calculations\n", + "No_of_Tones=Bss*10**6/stepsize;\n", + "Min_chips_required=math.log(No_of_Tones,2);\n", + "\n", + "#Result\n", + "print 'Minimum number of chips required are %d chips'%Min_chips_required" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum number of chips required are 20 chips\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.9, Page 179" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "e=2.71828; #Euler's number\n", + "Tprop=0.4; #Max propogation delay in sec\n", + "R=10; #data rate in Mbps\n", + "PackLen=400; #packet length in bits\n", + "\n", + "#Calculations\n", + "Tp=PackLen/R; #packet transmission time in microsec\n", + "a=Tprop/Tp;\n", + "G=Tp*10**-6*R*10**6/PackLen;#normalized offered traf\ufb01c load \n", + "#Slotted nonpersistent\n", + "S0=a*G*e**(-a*G)/(1-e**(-a*G)+a);#normalized throughput \n", + "#Unslotted nonpersistent\n", + "S1=G*e**(-a*G)/(1+(2*a)+e**(-a*G));#normalized throughput \n", + "#Slotted 1-persistent\n", + "S2=G*e**(-G*(1+a))*(1+a-e**(-a*G))/((1+a)*(1-e**(-a*G))+a*e**(-G*(1+a)));#normalized throughput \n", + "\n", + "#Results\n", + "print 'The Normalized throughput with an unslotted non persistent,a slotted persistent and a slotted 1-persistent CSMA protocol are \\n %.3f,%.3f and %.3f respectively'%(S0,S1,S2);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Normalized throughput with an unslotted non persistent,a slotted persistent and a slotted 1-persistent CSMA protocol are \n", + " 0.496,0.493 and 0.531 respectively\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.10, Page 188" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "Tprop=4; #maximum propogation delay in sec\n", + "R=10; # data rate in Mbps\n", + "PackLen=400.; #data packet length in bits\n", + "ACK=20; #length of ACK packet in bits\n", + "Tproc=1; #processing time(sec)\n", + "p=0.01;#probability that a data packet or its ACK can be corrupted during transmission\n", + "\n", + "#Calculations\n", + "Tp=PackLen/R; #packet transmission time in microsec\n", + "Ta=ACK/R; # transmission time for an ACK in microsec\n", + "T=Tp+2*Tprop+2*Tproc+Ta;# total time for transmission time \n", + "# Stop and wait ARQ\n", + "Eff0=(1-p)*Tp/((1-p)*T+p*Tp);\n", + "#SRP with window size W=8\n", + "W=8;\n", + "Eff1=(2+p*(W-1))/(2+p*(3*W-1));\n", + "#Go-Back-N protocol with window size W=8\n", + "Eff2=1./(1+W*(p/(1-p)));\n", + "\n", + "#Results\n", + "print 'The data link protocol efficiency with Stop and Wait protocol, SRP and GBN are \\n %.3f, %.3f abd %.3f respectively'%(Eff0,Eff1,Eff2);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The data link protocol efficiency with Stop and Wait protocol, SRP and GBN are \n", + " 0.763, 0.928 abd 0.925 respectively\n" + ] + } + ], + "prompt_number": 15 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb new file mode 100755 index 00000000..ccf24614 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb @@ -0,0 +1,178 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f50ddd5f96951e3a4bd117adfc40133b15c129b8f04d9b391396a08431c3aae2" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 8: Speech Coding and Channel Coding" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.1, Page 227" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Pdiff=-3.; #in dB\n", + "AMR1=12.2; #in kbps\n", + "AMR2=7.95; #in kbps\n", + "AMR3=4.75; #in kbps\n", + "\n", + "#Calculations\n", + "#CG(dB)=10math.log{(DPDCH(kbps)+DPCCH)/(DPDCH(AMR bit rate (kbps))+ DPCCH)}\n", + "CG1=10*math.log10((AMR1+AMR1*10**(Pdiff/10))/(AMR2+AMR1*10**(Pdiff/10)));\n", + "CG2=10*math.log10((AMR1+AMR1*10**(Pdiff/10))/(AMR3+AMR1*10**(Pdiff/10)));\n", + "\n", + "#Results\n", + "print 'By reducing the AMR bit rate from 12.2 to 7.95 kbps coverage gain becomes %.2f dB'%CG1;\n", + "print 'By reducing the AMR bit rate from 7.95 to 4.75 kbps coverage gain becomes %.2f dB'%CG2;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "By reducing the AMR bit rate from 12.2 to 7.95 kbps coverage gain becomes 1.15 dB\n", + "By reducing the AMR bit rate from 7.95 to 4.75 kbps coverage gain becomes 2.27 dB\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.2, Page 239" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import numpy as np\n", + "import sympy\n", + "from sympy import symbols\n", + "\n", + "#Variable declaration\n", + "K=4; #constraint length\n", + "r=1./2; #code rate(n/k)\n", + "x=symbols('x');#Defining x as a ploynomial variable\n", + "G1=1+x**2+x**3;\n", + "G2=1+x+x**2+x**3;\n", + "ins=np.array([1, 0, 1, 1, 1]);#input(first bit first)\n", + "\n", + "#Calculations&Results\n", + "#with reference to Fig 8.9 on page no 239\n", + "g1=np.array([1, 0, 1, 1]); #converting from G1 polynomial to bit form\n", + "g2=[1, 1, 1, 1];##converting from G2 polynomial to bit form\n", + "x1=np.convolve(g1,ins)\n", + "x2=np.convolve(g2,ins)\n", + "V1=x1%2;\n", + "V2=x2%2;\n", + "print \"Multiplexing the V1 and V2 to get required output sequence as\"\n", + "a=5;\n", + "for i in range(0,6):\n", + " print '%d%d'%(V2[a],V1[a]);\n", + " a=a-1;\n", + " " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Multiplexing the V1 and V2 to get required output sequence as\n", + "10\n", + "10\n", + "10\n", + "00\n", + "10\n", + "11\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8.3, Page 246" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import numpy as np\n", + "\n", + "#Variable declaration\n", + "BitStream=np.array([0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]);#Last bit to first bit\n", + "\n", + "# Interleaver\n", + "Input1=[[1, 0, 0, 0],[1,0,0,0],[1,1,1,0],[0,0,0,0]] #Writing data row wise\n", + "\n", + "#Calculations&Results\n", + "print \"GIven Bit stream is\",BitStream\n", + "print \"Input to interleaver is\",Input1\n", + "\n", + "Output1=np.array([0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1]); # Reading data column wise\n", + "print \"Output of interleaver is\",Output1\n", + "#De-interleaver\n", + "Input2=[[1, 1, 1, 0],[0,0,1,0],[0,0,1,0],[0,0,0,0]] #Writing o/p data row wise\n", + " # Let From 6th to 9th bits have Burst Error \n", + "print \"Input to de-interleaver is\",Input2\n", + " #Output of deinterleaver\n", + " \n", + "Output2= [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]; \n", + "print \"Output of de-interleaver is\",Output2\n", + "print \"Bits with Burst error were from 6th to 9th. But in output of de-interleaver, they relocated to positions 3rd, 6th, 10th and 14th.\";" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "GIven Bit stream is [0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 1]\n", + "Input to interleaver is [[1, 0, 0, 0], [1, 0, 0, 0], [1, 1, 1, 0], [0, 0, 0, 0]]\n", + "Output of interleaver is [0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 1]\n", + "Input to de-interleaver is [[1, 1, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 0, 0]]\n", + "Output of de-interleaver is [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]\n", + "Bits with Burst error were from 6th to 9th. But in output of de-interleaver, they relocated to positions 3rd, 6th, 10th and 14th.\n" + ] + } + ], + "prompt_number": 3 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb new file mode 100755 index 00000000..7efd7e54 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb @@ -0,0 +1,478 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:4f7509b378d9baa23589f40ce770175499b6cadfd03b87969971e1834bcae9ad" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 9: Modulation Schemes" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.1, Page 259" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy\n", + "from scipy.optimize import fsolve\n", + "\n", + "#Variable declaration\n", + "Pe=10**-6;#Probability of error\n", + "e=2.71828; #Euler's Number\n", + "\n", + "#Calculations\n", + "# For BPSK\n", + "#Pe(=10**-6)=e**(-x)/(2*sqrt(%pi*x)); where x=Eb/No\n", + "def f(x):\n", + " y=2.71828**(-x)/(2*math.sqrt(math.pi*x))-10**-6\n", + " return y\n", + "x = fsolve(f,0.1);\n", + "\n", + "#Results\n", + "print 'Eb/No For BPSK is %.2f dB'%(10*math.log10(x));\n", + "print 'FSK requires 3 dB more in terms of Eb/N0 to give the same Pe as BPSK so it comes out to be %.2f dB'%(10*math.log10(x)+3);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Eb/No For BPSK is 10.54 dB\n", + "FSK requires 3 dB more in terms of Eb/N0 to give the same Pe as BPSK so it comes out to be 13.54 dB\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.2, Page 259" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Pe=10.**-6;#Probability of error\n", + "No=10.**-10; # PSD in W/Hz\n", + "R=100*10**3; #data rate in bps\n", + "\n", + "#Calculations\n", + "#From Example 9.1, Eb/N0= 10.54dB (11.32) for Pe=10**-6 \n", + "#Therefore\n", + "Eb_No=11.32; #From Exa. 9.1\n", + "# Eb/No = A**2/(2*No*R);\n", + "A=math.sqrt(2*No*(Eb_No)*R);\n", + "\n", + "#Result\n", + "print 'Amplitude of a carrier signal is %.3f mV'%(A*1000);\n", + "#Incorrect answer in textbook" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Amplitude of a carrier signal is 15.047 mV\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.3, Page 267" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "B=['00','10','01','11','01','00','11','10','10','01','01','00'];#Given Bit stream\n", + "\n", + "#Calculations&Results\n", + "print \"Phase transition table for pi/4-DQPSK Modulation is given as \"\n", + "print \" By Referring Table 9.1 on page No 266 i.e\"\n", + "print \"Symbol Phase transition\"\n", + "print \"00 => 45\u00b0\"\n", + "print \"01 => 135\u00b0\"\n", + "print \"10 => -45\u00b0\"\n", + "print \"11 => -135\u00b0\"\n", + "print \"sym Dell phi(k) Phi(k)\"\n", + "#BitStream='001001110100111010010100';\n", + "\n", + "phase=0; #Taking initial phase as zero\n", + "for i in range(0,12):\n", + " if(B[i]=='00'):\n", + " phase=phase+45; \n", + " print ' %s 45 %d'%(B[i],phase);\n", + " \n", + " if(B[i]=='01'):\n", + " phase=phase+135;\n", + " print ' %s 135 %d'%(B[i],phase);\n", + " \n", + " if(B[i]=='10'):\n", + " phase=phase-45;\n", + " print ' %s -45 %d'%(B[i],phase);\n", + " \n", + " if(B[i]=='11'):\n", + " phase=phase-135;\n", + " print ' %s -135 %d'%(B[i],phase);\n", + " \n", + "\n", + "print 'final phase for the pi/4-DQPSK modulation method for given bitstream is %d degree'%phase" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Phase transition table for pi/4-DQPSK Modulation is given as \n", + " By Referring Table 9.1 on page No 266 i.e\n", + "Symbol Phase transition\n", + "00 => 45\u00b0\n", + "01 => 135\u00b0\n", + "10 => -45\u00b0\n", + "11 => -135\u00b0\n", + "sym Dell phi(k) Phi(k)\n", + " 00 45 45\n", + " 10 -45 0\n", + " 01 135 135\n", + " 11 -135 0\n", + " 01 135 135\n", + " 00 45 180\n", + " 11 -135 45\n", + " 10 -45 0\n", + " 10 -45 -45\n", + " 01 135 90\n", + " 01 135 225\n", + " 00 45 270\n", + "final phase for the pi/4-DQPSK modulation method for given bitstream is 270 degree\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.4, Page 270" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "CHBW=200; #Channel BW in KHz\n", + "R=270.83; #Data rate in kbps\n", + "Fc=900; #carrier frequency in MHz\n", + "\n", + "#Calculations\n", + "FreqShift=0.5*R;\n", + "#Transmitted Frequencies\n", + "Fh=Fc*1000+0.25*R;#Max\n", + "Fl=Fc*1000-0.25*R;#Min\n", + "BWEff=R/CHBW;\n", + "\n", + "#Results\n", + "print 'The frequency shift between binary 1 and binary 0 is %.3f kHz'%FreqShift;\n", + "print 'Maximum and Minimum value of transmitted frequencies are %.4f mHz and %.4f mHz respectively'%(Fh/1000,Fl/1000);\n", + "print 'Bandwidth efficiency is %.2f bps/Hz'%BWEff" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The frequency shift between binary 1 and binary 0 is 135.415 kHz\n", + "Maximum and Minimum value of transmitted frequencies are 900.0677 mHz and 899.9323 mHz respectively\n", + "Bandwidth efficiency is 1.35 bps/Hz\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.5, Page 271" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "R=270.; #data rate in kbps\n", + "Eb_No=6.; # in dB\n", + "GMSK=0.3; #Gaussian minimum shift keying\n", + "\n", + "#Calculations&Results\n", + "Tb=1./R *10**3; #in microsec\n", + "B=GMSK/Tb;\n", + "print '3-dB BW for a gaussian low pass filter is %.f kHz'%(B*1000);\n", + "PowerBW=1.41*R;\n", + "DegradFac=0.89;\n", + "Pe=math.erfc(math.sqrt(2*DegradFac*10**(0.1*Eb_No)));\n", + "print 'Power bandwidth in the RF channel is %.1f kHz'%PowerBW\n", + "print 'Bit error probability for GMSK is %.1e'%Pe; #Incorrect answer in textbook" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "3-dB BW for a gaussian low pass filter is 81 kHz\n", + "Power bandwidth in the RF channel is 380.7 kHz\n", + "Bit error probability for GMSK is 1.7e-04\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.6, Page 273" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "\n", + "#Variable declaration\n", + "Rs=19200; #symbols per second\n", + "states=64;\n", + "\n", + "#Calculations\n", + "Bits_symbol=math.log(states,2);\n", + "BitRate=Bits_symbol*Rs;\n", + "\n", + "#Result\n", + "print 'Bit Rate of the modulator is %.1f kbps'%(BitRate/1000)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Bit Rate of the modulator is 115.2 kbps\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.7, Page 274" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy\n", + "from scipy.optimize import fsolve\n", + "\n", + "#Variable declaration\n", + "Rb=144; #data rate in kbps\n", + "BW=36; #in MHz\n", + "Pb=3*10**-5;#probability of bit error\n", + "\n", + "#Calculations\n", + "Seff=Rb/BW; #spectral efficiency in bps/Hz\n", + "M=2**(Rb/BW); #since the channel is band limited\n", + "\n", + "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)] # refer page no 257 equ 9.35\n", + "def f(x):\n", + " y=(3./8)*math.erfc(math.sqrt((2./5)*x))-Pb #from eqn 9.66 and 9.35\n", + " return y\n", + " \n", + "x = fsolve(f,0.1)\n", + "\n", + "#Result\n", + "print 'For a rectangular constellation (refer Figure 9.12), with a Gaussian channel and matched \ufb01lter reception, the calculated Eb/No value is %.1f dB'%(10*math.log10(x));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For a rectangular constellation (refer Figure 9.12), with a Gaussian channel and matched \ufb01lter reception, the calculated Eb/No value is 12.9 dB\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.8, Page 274" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "import scipy\n", + "from scipy.optimize import fsolve\n", + "\n", + "#Variable declaration\n", + "Pb=10**-8;#BER probability\n", + "\n", + "#Calculations&Results\n", + "print \"For 16-PSK:\"\n", + "# Pb=0.5*Q(0.552*sqrt(Eb_No));\n", + "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)] # refer page no 257 equ 9.35\n", + "def f(x):\n", + " y=0.25*math.erfc(math.sqrt(0.5*0.552**2*x))-Pb\n", + " return y\n", + "\n", + "x = fsolve(f,0.1)\n", + "\n", + "print 'Using equation 9.50 we get Eb/No as %d dB (approx)'%round(10*math.log10(x));\n", + "\n", + "print \"For 16-QAM\"\n", + "#Pb=0.75*Q(sqrt(0.8*Eb_No));\n", + "def f(x1):\n", + " y=(3./8)*math.erfc(math.sqrt(0.4*x1))-Pb\n", + " return y\n", + " \n", + "x1 = fsolve(f,0.1)\n", + "\n", + "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)] # refer page no 257 equ 9.35\n", + "print 'Using equation 9.66 we get Eb/No as %d dB (approx)'%round(10*math.log10(x1));\n", + "print 'Thus 16-QAM has an advantage of about %d dB compared to 16-PSK'%(10*math.log10(x)-10*math.log10(x1));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For 16-PSK:\n", + "Using equation 9.50 we get Eb/No as 20 dB (approx)\n", + "For 16-QAM\n", + "Using equation 9.66 we get Eb/No as 16 dB (approx)\n", + "Thus 16-QAM has an advantage of about 4 dB compared to 16-PSK\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.9, Page 277" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "M=8; #number of different signal elements\n", + "Fc=250; #carrier frequency in kHz\n", + "DelF=25; #kHz\n", + "Pe=10**-6;#probability of error\n", + "\n", + "#Calculations\n", + "TotalBW=2*M*DelF;\n", + "nb=2*math.log(M,2)/(M+3);\n", + "#Pe=7*Q(z) and z=approx(5.08)\n", + "z=5.08;\n", + "Eb_No=(z)**2/math.log(M,2);\n", + "bits_sym=math.log(M,2);\n", + "\n", + "#Results\n", + "print 'Total bandwidth required is %d kHz \\n '%TotalBW;\n", + "print 'The bandwidth efficiency is %.4f \\n '%nb;\n", + "print 'The required Eb/No is %.3f dB \\n '%(10*math.log10(Eb_No));\n", + "print 'Carried bits per symbol are %d \\n '%bits_sym;" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total bandwidth required is 400 kHz \n", + " \n", + "The bandwidth efficiency is 0.5455 \n", + " \n", + "The required Eb/No is 9.346 dB \n", + " \n", + "Carried bits per symbol are 3 \n", + " \n" + ] + } + ], + "prompt_number": 10 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png Binary files differnew file mode 100755 index 00000000..8b71e082 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png Binary files differnew file mode 100755 index 00000000..21f83b0e --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png Binary files differnew file mode 100755 index 00000000..913873f0 --- /dev/null +++ b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png |
