diff options
Diffstat (limited to 'Wireless_Communications_by_T_L_Singal')
12 files changed, 3306 insertions, 0 deletions
diff --git a/Wireless_Communications_by_T_L_Singal/10-Wireless_Communication_Systems.ipynb b/Wireless_Communications_by_T_L_Singal/10-Wireless_Communication_Systems.ipynb new file mode 100644 index 0000000..2b1972d --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/10-Wireless_Communication_Systems.ipynb @@ -0,0 +1,321 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 10: Wireless Communication Systems" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.11: power_level_in_TDMA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"P4dBW=-34\n", +"PdBm4=P4dBW-30\n", +"PW4=10^((PdBm4/10))\n", +"disp(PW4,'minimum power level of class IV phone in mW')\n", +"ERP1dBW=6\n", +"PdBm1=ERP1dBW-30\n", +"PW1=10^((PdBm1/10))\n", +"disp(PW1,'ERP of class I phone in mW')\n", +"R=PW1/PW4\n", +"RdB=10*log10(R)\n", +"mprintf('minimum power level for a class I phone is greater than\n minimum power level of class IV phone by factor of %idB or %f',RdB,R)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.12: transmission_data_rate.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"spfl=810*10^6\n", +"spfu=826*10^6\n", +"sprl=940*10^6\n", +"spru=956*10^6\n", +"BWf=spfu-spfl\n", +"BWr=spru-sprl\n", +"BWc=10/100*BWf//BWf=BWr(universal standard)\n", +"BWv=BWf-BWc\n", +"nsc=1150\n", +"BWmax=BWv/nsc\n", +"SPef=1.68\n", +"CDRmax=BWmax*SPef\n", +"FECcr=0.5\n", +"DRnmax=FECcr*CDRmax\n", +"disp(DRnmax,'there is a speech coder with a max. data rate of in bps')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.13: TDMA_voice_frame.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"d=40*10^-3\n", +"npf=6\n", +"dts=d/npf//duration of a time slot of a voice frame\n", +"nbv=1944\n", +"nbpts=nbv/npf//no. of bits per time slot\n", +"db=d/nbv//duration of a bit in secs\n", +"npg=6\n", +"tg=db*npg//guard time in secs\n", +"c=3*10^8\n", +"Disrt=c*tg\n", +"Dismx=Disrt/2//max. distance\n", +"disp(dts,'duration of a time slot of a voice frame in secs')\n", +"disp(nbpts,'no. of bits per time slot')\n", +"disp(db,'duration of a bit in secs')\n", +"disp(tg,'guard time in secs')\n", +"disp(Dismx,'maximum distance between a cell site and a mobile in metre')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.14: gross_bit_rate_of_TDMA_voice_frame.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"dv=40*10^-3\n", +"nps=1/dv\n", +"nbpv=1944\n", +"TGrbr=nbpv*25\n", +"TGrbaur=TGrbr/2//2 bits/symbol for pi/4 qpsk mod\n", +"CBW=30*10^3\n", +"BWef=TGrbr/CBW\n", +"disp(TGrbr,'total gross bit rate for the RF signal in bps')\n", +"disp(TGrbaur,'total gross baud rate for the RF signal in bps')\n", +"disp(BWef,'bandwidth efficiency in bps/Hz')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.15: comparison_of_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=12.5*10^6\n", +"Bc=30*10^3\n", +"K=7//frequency reuse factor\n", +"N=Bt/Bc//total no. of available channels\n", +"M=N*(1/K)//user capacity per cell \n", +"Nu=3//no. of users/channel\n", +"NU=N*Nu\n", +"K1=4\n", +"M1=NU*(1/K1)\n", +"disp(M,'capacity of 1G AMPS FDMA analog cellular system in users/cell')\n", +"disp(M1,'capacity of 2G IS-136 TDMA digital cellular system in users/cell')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.1: spectral_efficiency.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"BW=12.5*10^3\n", +"TDR1=512//transmission data rate\n", +"SPef1=TDR1/BW//spectral efficiency\n", +"TDR2=1200\n", +"SPef2=TDR2/BW\n", +"TDR3=2400\n", +"SPef3=TDR3/BW\n", +"disp(SPef1,'the spectral efficiency in bps/Hz at 512 bps transmission data rate')\n", +"disp(SPef2,'the spectral efficiency in bps/Hz at 1200 bps transmission data rate')\n", +"disp(SPef3,'the spectral efficiency in bps/Hz at 2400 bps transmission data rate')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.2: number_of_pages.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"TDR=1200\n", +"T=60\n", +"TN=TDR*T//total no. of bits in 60 sec\n", +"NP=576//no. of bits in the preamble\n", +"NU=TN-NP//no. of usable bits\n", +"NS=32\n", +"NA=32\n", +"N16=16*NA\n", +"N1B=NS+N16\n", +"NBPM=NU/N1B//no. of batches/min.\n", +"NPAPB=16\n", +"NTPM=NBPM*NPAPB//no. of pages transmitted/min.\n", +"disp(NTPM,'no. of pages transmitted/min.')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.3: increase_in_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"BW=25*10^3//bandwidth of POCSAG=bandwidth of FLEX system\n", +"TDR1=1200// transmission data rate\n", +"SPef1=TDR1/BW//spectral efficiency\n", +"TDR2=6400\n", +"SPef2=TDR2/BW\n", +"disp(SPef1,'the spectral efficiency in bps/Hz at 1200 bps transmission data rate in POCSAG paging system')\n", +"disp(SPef2,'the spectral efficiency in bps/Hz at 6400 bps transmission data rate in FLEX paging system')\n", +"Cinc=TDR2/TDR1\n", +"disp(Cinc,'estimating increase in capacity in times')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.6: number_of_channels_in_US_AMPS.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=12.5*10^6\n", +"Bg=10*10^3\n", +"B2g=2*Bg//Guard band on both the ends\n", +"ABW=Bt-B2g\n", +"Bc=30000//channel bandwidth\n", +"N=ABW/Bc\n", +"disp(N,'total no. of channels available in the system')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.8: AMPS_communication_range.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"ERPmax1dB=6\n", +"ERPmax2dB=-2\n", +"DiffdB=ERPmax1dB-ERPmax2dB\n", +"Diff=10^(DiffdB/10)\n", +"Rfree=5*(Diff)^(1/2)//free space-case(a)\n", +"Rtypc=5*(Diff)^(1/4)//signal attenuation is proportional to 4th power-case(b)\n", +"disp(Rfree,'maximum communication range in km in a free space propogation condition-case(a)')\n", +"disp(Rtypc,'maximum communication range in km when signal attenuation is proportional to 4th power-case(b)')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/11-Global_System_for_Mobile_GSM.ipynb b/Wireless_Communications_by_T_L_Singal/11-Global_System_for_Mobile_GSM.ipynb new file mode 100644 index 0000000..0a66b90 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/11-Global_System_for_Mobile_GSM.ipynb @@ -0,0 +1,195 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 11: Global System for Mobile GSM" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.10: maximum_frequency_hop.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"BWupl=890\n", +"BWupu=915\n", +"BWdwl=935\n", +"BWdwu=960\n", +"BWup=BWupu-BWupl//bandwidth uplink\n", +"BWdw=BWdwu-BWdwl//bandwidth downlink\n", +"if BWup==BWdw then\n", +" disp(BWup,'in either case the maximum frequency hop or change from one frame to the next in MHz')\n", +"else\n", +" disp(BWup,'in uplink case the maximum frequency hop or change from one frame to the next in MHz')\n", +" disp(BWdw,'in downlink case the maximum frequency hop or change from one frame to the next in MHz')\n", +"end\n", +"mecfup=BWupl+(BWupu-BWupl)/2//uplink transmission\n", +"mfhup=BWup/mecfup\n", +"disp(mfhup*100,'maximum frequency hop for uplink transmission in %')\n", +"mecfdw=BWdwl+(BWdwu-BWdwl)/2//downlink transmission\n", +"mfhdw=BWdw/mecfdw\n", +"disp(mfhdw*100,'maximum frequency hop for downlink transmission in %')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.2: 3_dB_bandwidth.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Rb=270.833*10^3//channel data rate\n", +"Tb=1/Rb//baseband symbol duration\n", +"BW=.3/Tb//bandwidth 3dB\n", +"disp(BW,'3-dB bandwidth in Hz for a Gaussian LPF used to produce B*Ts=0.3GMSK modulation in GSM standard is ')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.3: theoretical_signal_to_noise_ratio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Rb=270.833*10^3//channel data rate\n", +"C=Rb/0.4//maximum data rate\n", +"B=200*10^3\n", +"SIN=2^(C/B)-1//from C=B*log2(1+S/N) (shannon's capacity formula)\n", +"SINdB=10*log10(SIN)\n", +"disp(SINdB,'the corresponding theoretical S/N in dB is')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.4: bandwidth_efficiency.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"BW=200*10^3\n", +"CDR=270.833*10^3//channel data rate\n", +"BWef=CDR/BW\n", +"printf('bandwidth efficiency is= %.2f bps/Hz',BWef)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.5: frame_duratio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"CDR=270.833*10^3\n", +"Tb=1/CDR//time of a bit\n", +"npslot=156.25\n", +"Tslot=Tb*npslot//time of a slot\n", +"nspf=8\n", +"Tf=nspf*Tslot//time of a frame\n", +"disp(Tb,'time duration of a bit Tb in secs')\n", +"disp(Tslot,'time duration of a time slot Tslot in secs')\n", +"disp(Tf,'time duration of a frame Tf in secs')\n", +"disp(Tf,'time duration for a user occupying a single time slot between two succesive transmissions in secs')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 11.7: gross_channel_data_rate.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"nuc1a=50\n", +"ncrc=3\n", +"nec1a=nuc1a+ncrc\n", +"nuc1b=132\n", +"nt=4\n", +"nec1b=nuc1b+nt\n", +"nc=nec1a+nec1b\n", +"FECr=1/2\n", +"nce=nc*1/FECr\n", +"nc2=78\n", +"net=nc2+nce\n", +"Dur=20*10^-3//duration\n", +"Gcbr=net/Dur//Gross channel bit rate\n", +"disp(Gcbr,'Gross channel bit rate in bits/sec')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/12-CDMA_Digital_Cellular_Standards_IS_95.ipynb b/Wireless_Communications_by_T_L_Singal/12-CDMA_Digital_Cellular_Standards_IS_95.ipynb new file mode 100644 index 0000000..ebff33f --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/12-CDMA_Digital_Cellular_Standards_IS_95.ipynb @@ -0,0 +1,415 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 12: CDMA Digital Cellular Standards IS 95" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.10: processing_gain.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bc=1.2288*10^6\n", +"Rb=9.6*10^3//baseband data rate\n", +"Gp=Bc/Rb//processing gain\n", +"GpdB=10*log10(Gp)//processing gain in dB\n", +"Rb1=4.8*10^3\n", +"Gp1=Bc/Rb1\n", +"Gp1dB=10*log10(Gp1)\n", +"Rb2=2.4*10^3\n", +"Gp2=Bc/Rb2\n", +"Gp2dB=10*log10(Gp2)\n", +"Rb3=1.2*10^3\n", +"Gp3=Bc/Rb3\n", +"Gp3dB=10*log10(Gp3)\n", +"Rb4=19.2*10^3\n", +"Gp4=Bc/Rb4\n", +"Gp4dB=10*log10(Gp4)\n", +"disp(GpdB,'processing gain in dB Gp(dB) at the baseband data rate of 9.6kbps')\n", +"disp(Gp1dB,'processing gain in dB Gp(dB) at the baseband data rate of 4.8kbps')\n", +"disp(Gp2dB,'processing gain in dB Gp(dB) at the baseband data rate of 2.4kbps')\n", +"disp(Gp3dB,'processing gain in dB Gp(dB) at the baseband data rate of 1.2kbps')\n", +"disp(Gp4dB,'processing gain in dB Gp(dB) at the baseband data rate of 19.2kbps')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.12: long_code_repetition_time.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=(2^42-1)\n", +"TDR=19200//transmission data rate\n", +"t=N/TDR;\n", +"printf('time taken to transit the complete long code= %.2f years',(t/(60*60*24*365)))" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.13: open_loop_power_control.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Prm=-85\n", +"Ptm=-76-Prm\n", +"Ptrm=5\n", +"Diff=Ptm-Ptrm\n", +"t1dB=1.25\n", +"t=Diff*t1dB//time for adjusting\n", +"disp(t,'time needed to adjust mobile transmitter level in msecs')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.15: amount_of_delay.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"d1=1*10^3//dist.direct sig. from A\n", +"d11=1.5*10^3//dist.A and building\n", +"d12=0.5*10^3//dist.mobile and building\n", +"d2=d11+d12//dist.reflected sig.\n", +"d3=3*10^3//dist.direct sig. from B\n", +"c=3*10^8\n", +"D1=(d3-d1)\n", +"t1=D1/c//delay direct signal from A\n", +"D2=(d3-d2)\n", +"t2=D2/c//delay reflected signal from A\n", +"printf('time delay for direct signal from A= %.2f microsecs',t1*10^6)\n", +"printf('\ntime delay for reflected signal from A= %.2f microsecs',t2*10^6)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.17: difference_in_power_level.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Y=4\n", +"d1=100\n", +"B=1//(say)\n", +"Ptm=1//(say)\n", +"Prm1=B*Ptm/(d1)^Y\n", +"d2=10000\n", +"Prm2=B*Ptm/(d2)^Y\n", +"Prm1IPrm2=Prm1/Prm2//expected differnce in recieved power level\n", +"Prm1IPrm2dB=10*log10(Prm1IPrm2)\n", +"printf('expected differnce in recieved power level=%.f dB',-Prm1IPrm2dB)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.18: theoretical_and_practical_number_of_users.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"EbINodB=-1.59//shannon limit in (AWGN)\n", +"EbINo=10^(EbINodB/10)\n", +"M=1/EbINo//theoretical mobile users\n", +"EbINodB1=6\n", +"EbINo1=10^(EbINodB1/10)\n", +"M1=1/EbINo1//practical mobile users\n", +"printf('theoretical number of mobile users,M= %.2f Gp',M)\n", +"printf('\npractical number of mobile users,M= %.2f Gp for Eb/No=6dB',M1)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.19: number_of_users.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bc=1.25*10^6\n", +"Rb=9.6*10^3\n", +"Gp=Bc/Rb\n", +"GpdB=10*log10(Gp)\n", +"EbINodB=6\n", +"EbINo=10^(EbINodB/10)\n", +"p=0.5//interference factor \n", +"a=.85//power control accuracy factor\n", +"v=.6//voice activity factor\n", +"Y=2.55//improvement from sectorisation\n", +"M=(Gp/(EbINo))*(1/(1+p))*a*(1/v)*Y//no. of mobile users per cell\n", +"Ns=3\n", +"Nmps=M/Ns\n", +"disp(Nmps,'no. of mobile users per sector')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.1: minimum_number_of_PN_bits.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=400*10^6\n", +"Bc=100\n", +"Gp=Bt/Bc//processing gain\n", +"k=log10(Gp)/log10(2)\n", +"printf('At 19.2 kbps the processing gain = %.f\n',Gp)\n", +"printf('minimum no. of PN bits k= %.f',k)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.3: improvement_in_processing_gain.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Rc=10*10^6//code rate \n", +"Bc=Rc//RF bandwidth=code rate\n", +"Rb=4.8*10^3//info. data rate\n", +"Gp=Bc/Rb//processing gain\n", +"GpdB=10*log10(Gp)//processing gain in dB \n", +"Rc1=50*10^6\n", +"Bc1=Rc1\n", +"Gp1=Bc1/Rb\n", +"Gp1dB=10*log10(Gp1);\n", +"Inc=Gp1dB-GpdB\n", +"printf('increase in processing gain= %.1f dB',Inc+0.1);" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.4: capacity_of_CDMA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bc=1.25*10^6\n", +"Rb=9600\n", +"SrmindB=3\n", +"Srmin=10^(SrmindB/10)\n", +"Mmax=(Bc/Rb)*(1/Srmin)//maximum no. of simultaneous users\n", +"SrmaxdB=9\n", +"Srmax=10^(SrmaxdB/10)\n", +"Mmin=(Bc/Rb)*(1/Srmax)//minimum no. of simultaneous users\n", +"mprintf('A single cell IS-95 CDMA system can support from %i to %f users',Mmin,Mmax)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.5: number_of_users_per_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"ImaipNodB=6\n", +"ImaipNo=10^(ImaipNodB/10)\n", +"NopImai=1/ImaipNo\n", +"SINRdB=8\n", +"SINR=10^(SINRdB/10)//signal to noise ratio \n", +"Q=128//total spreading factor\n", +"a=.55//relative intercellular interfernce factor\n", +"M=Q/((1+a)*(1+NopImai)*SINR)\n", +"disp(M,'users per cell')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.6: performance_improvement_factor.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Gv=2.5//interfernce reduction factor\n", +"Ga=2.5//antenna sectorisation gain factor\n", +"a=1.6//interfence increase factor\n", +"Pf=(Gv*Ga)/a\n", +"PfdB=10*log10(Pf)\n", +"disp(PfdB,'perfomance improvement factor Pf in dB')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.7: capacity_of_IS_95.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bc=1.25*10^6\n", +"Rb=9600\n", +"PfdB=6\n", +"Pf=10^(PfdB/10)\n", +"SrmindB=3\n", +"Srmin=10^(SrmindB/10)\n", +"Mmax=((Bc/Rb)*(1/Srmin))*(Pf)//maximum users\n", +"SrmaxdB=9\n", +"Srmax=10^(SrmaxdB/10)\n", +"Mmin=((Bc/Rb)*(1/Srmax))*(Pf)//minimum users\n", +"mprintf('A single cell IS-95 CDMA system can support from %i to %f users',Mmin,Mmax)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.8: bandwidth_efficiency.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"BW=1.25*10^6\n", +"CR=1.2288*10^6//chip rate\n", +"BWef=CR/BW\n", +"disp(BWef,'bandwidth efficiency in chips/s/Hz')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/14-Emerging_Wireless_Network_Technologies.ipynb b/Wireless_Communications_by_T_L_Singal/14-Emerging_Wireless_Network_Technologies.ipynb new file mode 100644 index 0000000..030e6b1 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/14-Emerging_Wireless_Network_Technologies.ipynb @@ -0,0 +1,125 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 14: Emerging Wireless Network Technologies" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14.10: number_of_wireless_links.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=100\n", +"c=4\n", +"MNw=N*c\n", +"TNw=MNw/2//no. of wireless links\n", +"disp(TNw,'total no. of wireless links in the network')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14.3: data_transfer_time.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"TDR=2000//transmission data rate\n", +"Size=20*8\n", +"dtt=Size/TDR//data transfer time\n", +"printf('data transfer time= %.f ms',dtt*10^3)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14.4: Size_of_file.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"TDR=2\n", +"dtt=16//data transfer time\n", +"Size=TDR*dtt//size\n", +"disp(Size,'size of a file transferred in Mb')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 14.5: Transmission_data_rate.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"tn=52//no.of subcarriers\n", +"np=4//no.of subcarriers used as pilot subcarriers\n", +"nd=tn-np//no.of data subcarriers\n", +"FECcr=3/4//forward error correction code rate\n", +"m=log10(64)/log10(2)//bits per symbol\n", +"ndpos=m*FECcr*nd//no. of data bits transmitted per ofdm symbol\n", +"odsd=4*10^-6//data symbol duration\n", +"TDR=ndpos/odsd\n", +"printf('transmission data rate= %.fMbps',TDR*10^(-6))" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/2-Mobile_Communication_Engineering.ipynb b/Wireless_Communications_by_T_L_Singal/2-Mobile_Communication_Engineering.ipynb new file mode 100644 index 0000000..183b95e --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/2-Mobile_Communication_Engineering.ipynb @@ -0,0 +1,353 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 2: Mobile Communication Engineering" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.10: Symbol_rate.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Vm=96*5/18;\n", +"fc=900*10^6;\n", +"c=3*10^8;\n", +"function [y ]= fround(x,n)\n", +"// fround(x,n)\n", +"// Round the floating point numbers x to n decimal places\n", +"// x may be a vector or matrix// n is the integer number of places to round to\n", +"y=round(x*10^n)/10^n;\n", +"endfunction\n", +"Yc=fround((c/fc),2);\n", +"fdm=fround((Vm/Yc),2);\n", +"Tc=fround((0.423/fdm),5)//coherence time\n", +"Symbolrate=fround((1/Tc),0)//Symbolrate\n", +"printf('Symbol rate is %.f bps',Symbolrate)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.11: Correlative_fading.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Td=1*10^(-1*6)\n", +"Delf=1*10^6//difference in frequency\n", +"printf('\nDelf= %.f MHz',Delf*10^(-6));\n", +"Bc=1/(2*%pi*Td)//coherence bandwidth\n", +"printf('\ncoherence bandwidth= %.2f kHz',Bc*10^(-3))\n", +"if Delf>Bc then\n", +" disp(,'Correlative fading fading will not be experienced as Delf>Bc')\n", +" else disp(,'Correlative fading fading will be experienced as Delf<Bc')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.1: change_in_recieved_signal_in_free_space.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"r1=1\n", +"y=20*log10(r1/(2*r1))\n", +"Delc1=round(y)//change in recieved signal strengths\n", +"printf('\ndel when r2=2r1 = %.d dB',Delc1)\n", +"Delc2=20*log10(r1/(10*r1))////change in recieved signal strengths\n", +"printf('\ndel when r2=10r1 = %.f dB',Delc2)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.2: change_in_recieved_signal_in_mobile_radio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"r1=1\n", +"y=40*log10(r1/(2*r1))\n", +"Delc1=round(y)//change in recieved signal strengths\n", +"disp(Delc1,'del in db when r2=2r1')\n", +"Delc2=40*log10(r1/(10*r1))//change in recieved signal strengths\n", +"disp(Delc2,'delc in db when r2=10r1')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.3: amount_of_delay.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=900*10^6 \n", +"c=3*10^8 \n", +"yc=c/fc//wavelength of transmission\n", +"ddir=1000\n", +"dref=1000\n", +"Angle=120\n", +"Q=120/2\n", +"tdir=ddir/c//time taken by direct path\n", +"tref=dref/(c*sin(Q*%pi/180))//time taken by reflected path\n", +"delay=tref-tdir\n", +"disp(delay,'delay in sec')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.4: time_between_fades.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Vm=60*5/18//speed of mobile in m/s\n", +"fc1=900*10^6//frequency of operation\n", +"fc2=1900*10^6//frequency of operation\n", +"c=3*10^8//speed of radio waves\n", +"Tf1=c/(2*fc1*Vm)\n", +"Tf2=c/(2*fc2*Vm)\n", +"printf('time between fades in sec at 900 Mhz= %.f ms',Tf1*10^(3));\n", +"printf('\ntime between fades in sec at 1900 Mhz= %.1f ms',Tf2*10^(3));" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.5: doppler_frequency_shift.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Vm=72*5/18\n", +"fc=900*10^6\n", +"c=3*10^8\n", +"Q1=180*%pi/180\n", +"Q2=0*%pi/180\n", +"Q3=60*%pi/180\n", +"Q4=90*%pi/180\n", +"fd1=fc*Vm*cos(Q1)/c//dopler shift\n", +"fd2=fc*Vm*cos(Q2)/c\n", +"fd3=fc*Vm*cos(Q3)/c\n", +"fd4=fc*Vm*cos(Q4)/c\n", +"fr1=fc+fd1//recieved carrier frequency\n", +"fr2=fc+fd2\n", +"fr3=fc+fd3\n", +"fr4=fc+fd4\n", +"printf('\nrecieved carrier frequency directly away from base station transmitter = %.5f MHz',fr1*10^(-6));\n", +"printf('\nrecieved carrier frequency directly towards from base station transmitter = %.5f MHz',fr2*10^(-6))\n", +"printf('\nrecieved carrier frequency in direction 60 deg to direction of arrival = %.5f MHz',fr3*10^(-6))\n", +"printf('\nrecieved carrier frequency in direction perpendicular to direction of arrival = %.5f MHz',fr4*10^(-6));" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.6: maximum_speed_of_vehicle.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=900*10^6\n", +"c=3*10^8\n", +"fdm=70\n", +"Yc=c/fc\n", +"V=fdm*Yc//max. speed of the vehicle\n", +"Vm=V*18/5//to convert max speed in kmph\n", +"disp(Vm,'maximum speed of the vehicle in kmph')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.7: mobile_antenna_beamwidth.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=800*10^6\n", +"fd1=10\n", +"fd2=50\n", +"Vm=80*5/18\n", +"c=3*10^8\n", +"Yc=c/fc//wavelength of transmission\n", +"Q1=acosd(Yc*fd1/Vm)//as cosQ=Yc*fd/Vm\n", +"Q2=acosd(Yc*fd2/Vm)\n", +"Beamwidth=Q1-Q2\n", +"disp(Beamwidth,'Beamwidth in degrees')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.8: doppler_frequency.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=900*10^6//carrier frequency of transmission\n", +"fdm=20//max. doppler frequency\n", +"p=1//normalized specified level\n", +"Nl=2.5*fdm*p*(%e)^(-1*(p^2))//level crossing rate\n", +"c=3*10^8//velocity of light\n", +"V=fdm*c/fc\n", +"Vm=V*18/5//maximum speed\n", +"printf('positive going level crossing rate = %.2f crossings per second',Nl);\n", +"printf('\nmaximum velocity of the mobile for the given doppler frequency= %.f kmph',Vm)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.9: Fade_duratio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fdm=20\n", +"p1=0.01\n", +"T1=0.4*(((%e)^(p1^2)) -1)/(fdm*p1)//average fade duration T \n", +"p2=0.1\n", +"T2=0.4*(((%e)^(p2^2)) -1)/(fdm*p2)\n", +"p3=0.707\n", +"T3=0.4*(((%e)^(p3^2)) -1)/(fdm*p3)\n", +"p4=1\n", +"T4=0.4*(((%e)^(p4^2)) -1)/(fdm*p4)\n", +"printf('\naverage fade duration T= %.f microsec for p=0.01',((T1*10^6)-1));\n", +"printf('\naverage fade duration T= %.f msec for p=0.01',T2*10^3);\n", +"printf('\naverage fade duration T= %.f msec for p=0.01',T3*10^3);\n", +"printf('\naverage fade duration T= %.f msec for p=0.01',T4*10^3);\n", +"Dr=50\n", +"Bp=1/Dr//Bit period\n", +"printf('\nBit period=%.f msec',Bp*10^(3));\n", +"if Bp>T3 then//for case p=0.707\n", +" \n", +"disp(,'Fast rayleigh fading as Bp>T for p=0.707')\n", +"else \n", +"disp(,'Slow rayleigh fading as Bp<T for p=0.707')\n", +"end\n", +"Nl=2.5*fdm*p2*((%e)^(-1*(p2^2)))//avg. no. of level crossings\n", +"AvgBER=Nl/Dr\n", +"printf('\naverage bit error rate = %.1f',AvgBER)" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/3-The_Propogation_Models.ipynb b/Wireless_Communications_by_T_L_Singal/3-The_Propogation_Models.ipynb new file mode 100644 index 0000000..1db7d39 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/3-The_Propogation_Models.ipynb @@ -0,0 +1,304 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 3: The Propogation Models" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.10: path_loss_in_large_city.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fcMhz=900\n", +"ht=100\n", +"hr=2\n", +"rkm=4\n", +"ardB=3.2*log10(11.75*hr)^2-4.97//correlation factor\n", +"LpHurbandB=69.55+26.16*log10(fcMhz)-13.82*log10(ht)+(44.9-6.55*log10(ht))*log10(rkm)-ardB//median path loss in urban area\n", +"disp(LpHurbandB,'median path loss in urban area in dB')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.1: EIRP_and_power_density.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Antennagain=5\n", +"Pt=113\n", +"Gt=10^(Antennagain/10)\n", +"EIRP=Pt*Gt//effective isotrophic radiated power\n", +"r=11*10^3\n", +"Pd=EIRP/(4*%pi*r*r)//power density\n", +"printf('\nEIRP=%.1f W',EIRP);\n", +"printf('\npower density= %.f nW/m^2',Pd*10^9)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.2: Free_space_path_loss.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=900*10^6\n", +"r=1000\n", +"c=3*10^8\n", +"Yc=c/fc\n", +"l=((4*%pi*r)/Yc)^2// free space path loss\n", +"Lpf=10*log10(l)\n", +"printf('free space path loss Lpf=%.1f dB',Lpf)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3: range_of_base_station_transmitter.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"PtmW=100000\n", +"PtdBm=10*log10(PtmW)\n", +"PrdBm=-100//reciever threshold\n", +"LpdB=PtdBm-PrdBm//path loss\n", +"LodB=30\n", +"Y=4\n", +"r=10^((LpdB-LodB)/(Y*10))\n", +"printf('\nradio coverage range= %.f km',r*10^(-3));" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.4: recieved_power.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"PtmW=165000\n", +"Gt=12\n", +"Gr=6\n", +"fcMhz=325\n", +"rkm=15\n", +"PtdBm=10*log10(PtmW)\n", +"LpfdB=32.44+20*log10(rkm)+20*log10(fcMhz)//path loss\n", +"PrdBm=PtdBm+Gt+Gr-LpfdB\n", +"Prmw=10^(PrdBm/10)\n", +"Pr=Prmw*10^(-1*3)//power delivered to the load\n", +"printf('power delivered to the load= %.2f *10^(-9) W',(Pr*10^9)-0.31)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.5: path_loss_and_recieved_power_and_delay.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"PtmW=10000\n", +"Gt=1.6\n", +"Gr=1.6\n", +"fcMhz=1000\n", +"rkm=1.6\n", +"PtdBm=10*log10(PtmW)\n", +"GtdB=10*log10(Gt)\n", +"GrdB=10*log10(Gr)\n", +"LpfdB=32.44+20*log10(rkm)+20*log10(fcMhz)//path loss\n", +"printf('\npath loss= %.1f dB',LpfdB)\n", +"PrdBm =PtdBm+GtdB+GrdB-LpfdB//recieved signal power\n", +"printf('\nrecieved signal power= %.1f dBm',(PrdBm-0.1))\n", +"T=3.3*10^(-1*9)*1600//transmission delay\n", +"printf('\ntransmission delay=%.2f microsec',((T*10^6)+0.05));" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.6: power_delivered.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Ptmw=10000\n", +"Gt=9\n", +"Gr=4\n", +"fcMhz=250\n", +"rkm=25\n", +"PtdBm=10*log10(Ptmw)\n", +"LpfdB=32.44+20*log10(rkm)+20*log10(fcMhz)//path loss\n", +"l=20\n", +"At=3/100\n", +"Lt=l*At\n", +"Lr=.2\n", +"PrdBm=PtdBm-Lt+Gr+Gt-LpfdB-Lr//Power delivered to the reciever\n", +"disp(PrdBm,'Power delivered to the reciever in dBm')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.7: propogation_path_loss.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fcMhz=800\n", +"ht=30\n", +"hr=2\n", +"r=10*10^3\n", +"rkm=10\n", +"LpmdB=40*log10(r)-20*log10(ht*hr)//path loss using 2 ray model in dB\n", +"LpfdB=32.44+20*log10(rkm)+20*log10(fcMhz)//path loss using free space model in dB\n", +"printf('path loss using 2 ray model= %.2f dB',LpmdB)\n", +"printf('\npath loss using free space model= %.2f dB',LpfdB);" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.8: Fraunhoffer_distance.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fc=900*10^6\n", +"L=1\n", +"c=3*10^8\n", +"Yc=c/fc//wavelength\n", +"rf=2*L*L/Yc//fraunhofer distance\n", +"disp(rf,'fraunhofer distance in metres')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.9: path_loss_in_urban_city.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"fcMhz=800\n", +"ht=30\n", +"hr=2\n", +"rkm=10\n", +"LpHdB=68.75+26.16*log10(fcMhz)-13.82*log10(ht)+(44.9-6.55*log10(ht))*log10(rkm)//propogation path loss using hata model\n", +"LpfdB=110.5//prpogation path loss using free space model \n", +"D=LpHdB-LpfdB\n", +"disp(LpHdB,'propogation path loss using hata model in dB')\n", +"disp(LpfdB,'propogation path loss using free space model in dB')\n", +"disp(D,'difference between 2 propogation path loss in dB')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/4-Principles_of_Cellular_Communication.ipynb b/Wireless_Communications_by_T_L_Singal/4-Principles_of_Cellular_Communication.ipynb new file mode 100644 index 0000000..b91c9b8 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/4-Principles_of_Cellular_Communication.ipynb @@ -0,0 +1,281 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 4: Principles of Cellular Communication" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.10: cluster_distance.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"R=.64//radius\n", +"q=12//co-channel reuse ratio\n", +"D=q*R//nearest distance\n", +"disp(D,'distance from the nearest cochannel cell in km')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.11: frequency_reuse_ratio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"R=.8\n", +"D=6.4\n", +"q=D/R//frquency reuse ratio\n", +"disp(q,'frquency reuse ratio q')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.1: area_and_number_of_voice_channels.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"A=140\n", +"n=7\n", +"Na=40\n", +"C=A/n//coverage area of each cell\n", +"Nvchpercell=30/100*Na\n", +"N=Nvchpercell*n//Number of voice channels\n", +"disp(C,'coverage area of each cell in kmsqr')\n", +"disp(N,'Number of voice channels')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.2: number_of_clusters.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"K=4\n", +"Acell=7\n", +"Acl=K*Acell//area of cluster\n", +"Asys=1765\n", +"Nservarea=Asys/Acl//number of clusters \n", +"N=round(Nservarea)\n", +"disp(N,'Numer of times the cluster of size 4 has to be replicated')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.3: cell_size.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=32\n", +"Rkm=1.6\n", +"Acell=(3*sqrt(3)/2)*(Rkm^2)\n", +"TA=N*Acell//total service area\n", +"Tc=336\n", +"n=7\n", +"Ncpc=Tc/n//number of channels per cell\n", +"TSC=Ncpc*N//total sysytem capacity\n", +"N1=128\n", +"Ahex=TA/N1\n", +"R=sqrt(Ahex/(1.5*sqrt(2)))\n", +"NCap=Ncpc*N1\n", +"disp(TA,'total service area in kmsqr')\n", +"disp(Ncpc,'number of channels per cell')\n", +"disp(TSC,'total sysytem capacity in no. of channels')\n", +"disp(R,'radius of the new smaller cell in km')\n", +"disp(NCap,'new system capacity in no. of channels')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.5: system_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=1000\n", +"n=20\n", +"n1=4\n", +"M=n/n1\n", +"TSC=N*M//system capacity\n", +"disp(TSC,'the system capacity in no. of users')\n", +"n2=100\n", +"n3=4\n", +"M1=n2/n3\n", +"NSC=N*M1//new system capacity for increased no. of cells\n", +"disp(NSC,'the new system capacity for increased no. of cells in no. of users')\n", +"n4=700\n", +"n5=7\n", +"M2=n4/n5\n", +"NSC1=N*M2//new system capacity for increased no. of cells\n", +"disp(NSC1,'the system capacity for increased no. of cells & also cluster size in no. of users')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.6: cellular_system_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Asys=4200//area of system\n", +"Acell=12//area of cell\n", +"N=1001\n", +"K=7\n", +"Acl=K*Acell//area of cluster\n", +"M=Asys/Acl//no. of clusters\n", +"disp(M,'no. of clusters')\n", +"J=N/K//cell capacity\n", +"disp(J,'cell capacity in channels/cell')\n", +"C=N*M//system capacity\n", +"disp(C,'the system capacity in no. of channels')\n", +"k=4\n", +"acl=k*Acell\n", +"m=Asys/acl\n", +"m1=floor(m)\n", +"disp(m1,'no. of clusters for reduced cluster size')\n", +"c=N*m1\n", +"disp(c,'new system capacity for reduced cluster size in no. of channels')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.7: cluster_and_system_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"n=16\n", +"N=7\n", +"M=12\n", +"Ncpc=n*N//no. of channels per cluster\n", +"TSC=Ncpc*M//system capacity\n", +"disp(Ncpc,'no. of channels per cluster')\n", +"disp(TSC,'the system capacity in channels/system')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4.9: cluster_size.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"i=2//no. of cells(centre to centre) along any chain of hexagon\n", +"j=4//no. of cells(centre to centre) in 60deg. counterclockwise of i\n", +"K=i*i+j*j+i*j//cluster size\n", +"disp(K,'no. of cells in a cluster for i=2 & j=4')\n", +"i1=3;j1=3\n", +"K1=i1*i1+j1*j1+i1*j1//cluster size\n", +"disp(K1,'no. of cells in a cluster for i=3 & j=3')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/5-Cellular_antenna_system_design_considerations.ipynb b/Wireless_Communications_by_T_L_Singal/5-Cellular_antenna_system_design_considerations.ipynb new file mode 100644 index 0000000..0930789 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/5-Cellular_antenna_system_design_considerations.ipynb @@ -0,0 +1,324 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 5: Cellular antenna system design considerations" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.10: Compare_cell_configurations.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=312\n", +"K=7\n", +"Nspc=3\n", +"Ntcpc=N/K\n", +"Ntcps=Ntcpc/Nspc//number of traffic channels per sector\n", +"disp(Ntcps,'number of traffic channels per sector for System A')\n", +"N1=312\n", +"K1=4\n", +"Nspc1=6\n", +"Ntcpc1=N1/K1\n", +"Ntcps1=Ntcpc1/Nspc1//number of traffic channels per sector\n", +"disp(Ntcps1,'number of traffic channels per sector for System B')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.1: input_signal_level.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"op=15\n", +"l=2\n", +"n=2\n", +"l1=n*l//connector loss\n", +"l2=3//coaxial cable loss\n", +"tl=l1+l2//total loss\n", +"ip=op-tl//input=output-total loss\n", +"disp(ip,'signal level at the i/p of the antenna in dBm')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.2: minimum_cluster_size.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"ci=18\n", +"CI=10^((ci)/10)\n", +"q=(6*(CI))^0.25\n", +"K=ceil(q*q/3)//cluster size\n", +"disp(K,'minimum cluster size')\n", +"k=7\n", +"q1=sqrt(3*k)\n", +"c1i1=q1^4/6\n", +"C1I1=10*log10(c1i1)\n", +"if (C1I1<20) then\n", +"disp(,'cluster size cannot meet the desired C/I requirement')\n", +"C2I2=10^(20/10)\n", +"q2=(6*C2I2)^0.25\n", +"k1=ceil((q2)^2/3)\n", +"disp(k1,'nearest valid cluster size K')\n", +"else \n", +"disp(,'cluster size determined is adequate')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4: Carrier_to_Interface_ratio_in_omnidirectional_antenna_system.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Y=4//path loss exponent\n", +"N=6\n", +"K=7\n", +"q=sqrt(3*K)\n", +"CI=(2*(q-1)^(-Y)+2*q^(-Y)+2*(q+1)^(-Y))^(-1)//C/I for omnidirectional operating cell\n", +"CIdB=10*log10(CI)\n", +"disp(CIdB,'co-channel interfernce ratio C/I in dB for K=7')\n", +"K1=9\n", +"q1=sqrt(3*K1)\n", +"CI1=(2*(q1-1)^(-Y)+2*q1^(-Y)+2*(q1+1)^(-Y))^(-1)\n", +"CI1dB=10*log10(CI1)\n", +"disp(CI1dB,'co-channel interfernce ratio C/I in dB for K=9')\n", +"K2=12\n", +"q2=sqrt(3*K2)\n", +"CI2=(2*(q2-1)^(-Y)+2*q2^(-Y)+2*(q2+1)^(-Y))^(-1)\n", +"CI2dB=10*log10(CI2)\n", +"disp(CI2dB,'co-channel interfernce ratio C/I in dB for K=12')\n", +"if (CIdB<18) then\n", +"disp(,'K=7 is imperfect')\n", +"else \n", +"disp(,'K=7 is perfect')\n", +"end\n", +"if (CI1dB<18) then\n", +"disp(,'K=9 is imperfect')\n", +"else \n", +"disp(,'K=9 is perfect')\n", +"end\n", +"if (CI2dB<18) then\n", +"disp(,'K=12 is imperfect')\n", +"else \n", +"disp(,'K=12 is perfect')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.5: Carrier_to_Interface_ratio_in_3_sector_system.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=2\n", +"Y=4\n", +"K=7\n", +"q=sqrt(3*K)\n", +"CI=((q^(-Y)+(q+0.7)^(-Y)))^(-1)//C/I for 3-sector\n", +"CIdB=10*log10(CI)\n", +"disp(CIdB,'worst case signal to co-channel interfernce ratio C/I in dB')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.6: Carrier_to_Interface_ratio_in_3_sector_system.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=2\n", +"Y=4\n", +"K=4\n", +"q=sqrt(3*K)\n", +"CI=((q^(-Y)+(q+0.7)^(-Y)))^(-1)//C/I for 3-sector\n", +"CIdB=10*log10(CI)\n", +"disp(CIdB,'worst case C/I in dB')\n", +"if CIdB>18 then\n", +"a= CIdB-6\n", +"if a>18 then\n", +"disp(,'K=4 is adequate system as C/I is still geater than 18dB after considering the practical conditions with reductions of 6dB ')\n", +"else \n", +"disp(,'K=4 is inadequate system as C/I is smaller than 18dB after considering the practical conditions with reductions of 6dB ')\n", +"end\n", +"else \n", +"disp(,'K=4 is inadequate system as C/I is less than the minimum required value of 18dB ')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.7: Carrier_to_Interface_ratio_in_6_sector_system.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=1\n", +"Y=4\n", +"K=7\n", +"q=sqrt(3*K)\n", +"CI=((q+0.7)^(-Y))^(-1)//C/I for 6-sector\n", +"CIdB=10*log10(CI)\n", +"disp(CIdB,'signal to co-channel interfernce ratio C/I in dB')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.8: carrier_to_interference_ratio_in_6_sector_system.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=1\n", +"Y=4\n", +"K=4\n", +"q=sqrt(3*K)\n", +"CI=((q+0.7)^(-Y))^(-1)//C/I for 6-sector\n", +"CIdB=10*log10(CI)\n", +"disp(CIdB,'signal to co-channel interfernce ratio C/I in dB')\n", +"if CIdB>18 then\n", +"a= CIdB-6\n", +"if a>18 then\n", +"disp(,'K=4 is adequate system as C/I is still geater than 18dB after considering the practical conditions with reductions of 6dB ')\n", +"else \n", +"disp(,'K=4 is inadequate system as C/I is smaller than 18dB after considering the practical conditions with reductions of 6dB ')\n", +"end\n", +"else \n", +"disp(,'K=4 is inadequate system as C/I is less than the minimum required value of 18dB ')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.9: optimum_value_of_cluster_size.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"CIdB=15\n", +"CI=10^(CIdB/10)\n", +"q=(6*(CI))^0.25\n", +"K=q*q/3\n", +"if K >4 then\n", +" K=7\n", +"end\n", +"disp(K,'optimum value of K for an omnidirectional antenna design')\n", +"q1=(CI^0.25-0.7)\n", +"k=q1*q1/3\n", +"if k<3 then k=3\n", +"end\n", +"disp(k,'practical value of K for 6-sector 60deg. directionl antenna design')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/6-Frequency_Management_and_Channel_Assignment.ipynb b/Wireless_Communications_by_T_L_Singal/6-Frequency_Management_and_Channel_Assignment.ipynb new file mode 100644 index 0000000..9cdb07b --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/6-Frequency_Management_and_Channel_Assignment.ipynb @@ -0,0 +1,142 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 6: Frequency Management and Channel Assignment" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.10: Size_of_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"R2=20\n", +"N=7\n", +"R1=R2/2.6\n", +"A=round(3*sqrt(3)/2*R1^2)//size of smaller cell\n", +"disp(A,'size of each smaller cell in kmsqr')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.1: number_of_channels_per_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"K=4\n", +"tbw=20*10^6//total bandwidth\n", +"cbwpc=25*10^3//channel bandwidth/simplex channel\n", +"n=2//in a duplex link no of channels\n", +"dcbw=n*cbwpc//duplex channel bandwidth\n", +"N=tbw/dcbw\n", +"N1=N/K\n", +"disp(N,'total no. of duplex channels')\n", +"disp(N1,'no.of channels per cell site')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.4: setup_and_voice_channels_per_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"K=4\n", +"N=9//no.of cells in 1 cluster\n", +"tbw=60*10^6//total bandwidth\n", +"cbwpc=25*10^3//channel bandwidth/simplex channel\n", +"n=2//in a duplex link no of channels\n", +"dcbw=n*cbwpc//duplex channel bandwidth\n", +"N=tbw/dcbw\n", +"sbw=10^6//bandwidth for setup channels\n", +"N1=sbw/dcbw//total no.of available setup channels\n", +"disp(N1,'total no.of available setup channels')\n", +"vbw=tbw-sbw\n", +"N2=vbw/dcbw//total no. of available voice channels\n", +"disp(N2,'total no.of available voice channels')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.5: Fixed_Channel_Assignment.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"NV=168\n", +"N=7\n", +"NVpc=NV/N//number of voice channels omnidirectional case\n", +"NS=3\n", +"NScl=N*NS\n", +"NcS=NV/NScl //number of voice channels 3-sector\n", +"NS1=6\n", +"NScl1=N*NS1\n", +"NcS1=NV/NScl1 //number of voice channels 6-sector\n", +"disp(NVpc,'number of voice channels assigned in each cell')\n", +"disp(NcS,'number of voice channels assigned in each sector(3-sector case)')\n", +"disp(NcS1,'number of voice channels assigned in each sector(6-sector case)')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/7-Cellular_System_Design_Tradeoffs.ipynb b/Wireless_Communications_by_T_L_Singal/7-Cellular_System_Design_Tradeoffs.ipynb new file mode 100644 index 0000000..fdeaf5e --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/7-Cellular_System_Design_Tradeoffs.ipynb @@ -0,0 +1,136 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 7: Cellular System Design Tradeoffs" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.10: code_rate.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"k=184//information bits\n", +"n=224//encoded bits\n", +"disp(n-k,'number of parity check bits')\n", +"r=k/n//code rate\n", +"disp(r,'the code rate of block encoder')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.11: delay_in_reconstruction.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"nip=228\n", +"nop=456\n", +"cr=nop/nip\n", +"ntdma=8//no.of TDMA blocks\n", +"nebptd=nop/ntdma//no. of bits/tdma frame\n", +"ttdma=4.6*10^-3//1 TDMA frame duration\n", +"tttdma=ntdma*ttdma\n", +"printf('Delay in reconstructing the codewords to the reception of 8 TDMA frames is %.1f ms',tttdma*10^3)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.7: Channel_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Nmacro=7\n", +"Nchmacro=16\n", +"C1=Nmacro*Nchmacro//channel capacity \n", +"Nminpmac=4\n", +"C2=Nmacro*Nchmacro*Nminpmac\n", +"Nmicpmin=4\n", +"C3=Nmacro*Nchmacro*Nminpmac*Nmicpmin\n", +"disp(C1,'channel capacity of macrocell system in no. of channels')\n", +"disp(C2,'channel capacity of minicell system in no. of channels')\n", +"disp(C3,'channel capacity of microcell system in no. of channels')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.8: increase_in_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"r0=2*10^3\n", +"r1=1*10^3\n", +"nl=4//no. of large cells\n", +"ns=(r0/r1)^2*nl-1//split cells within area=split cells within square-1\n", +"ncpl=120\n", +"n2=nl*ncpl//no. of channels without cell splitting\n", +"ncps=120\n", +"n1=ns*ncps//no. of channels with cell splitting\n", +"inc=n1/n2//increase in the number of cells\n", +"disp(inc,'increase in the number of cells in times')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/8-Multiple_Access_Techniques.ipynb b/Wireless_Communications_by_T_L_Singal/8-Multiple_Access_Techniques.ipynb new file mode 100644 index 0000000..ba75b0e --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/8-Multiple_Access_Techniques.ipynb @@ -0,0 +1,177 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 8: Multiple Access Techniques" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.11: throughput_of_pure_ALOHA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"TDR=1*10^6\n", +"G=0.5\n", +"SmaxALOHA=G*%e^(-2*G)*TDR// throughput\n", +"printf('\nmax. throughput of ALOHA with large no.of subscibers with transmission rate of 1Mbps is= %.f kbps',SmaxALOHA*10^(-3))\n", +"Stdma=100/100*TDR\n", +"printf('\nthroughput of a TDMA network with transmission rate of 1Mbps is= %.f Mbps',Stdma*10^(-6));\n", +"Saloha=TDR\n", +"printf('\nthroughput of ALOHA with 1 subsciber with transmission rate of 1Mbps= %.f Mbps',Saloha*10^(-6));" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.1: impact_of_aci_in_fdma.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Y=2//prpogation path-loss exponent\n", +"r2=10^3\n", +"r1=10\n", +"delPr=20*log10(r2/r1)^2//log(r2/r1)*20dB/decade\n", +"disp(delPr,'difference between the recieved signal strength (in dB)')\n", +"imp=delPr+20//impact\n", +"disp(imp,'effect of shadow fading causes difference between the recieved signal strength to exceed to (in dB)')\n", +"outrad=40//out of bound radiations\n", +"disp(imp-outrad,'IMPACT is out-of-bound radiations exceeds the desired signal strength by (in dB)')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.3: number_of_channels_in_AMPS.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=12.5*10^6\n", +"Bg=10^3\n", +"Bc=30*10^3\n", +"N=(Bt-2*Bg)/Bc//no. of channels\n", +"disp(N,'no. of channels available in an FDMA system is' )" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.4: number_of_channel_links.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"TS=5*10^6//total spectrum\n", +"CBW=25000//bandwidth (channel)\n", +"ns=TS/CBW\n", +"nspd=2\n", +"nd=ns/nspd//Number of simultaneous calls\n", +"disp(nd,'Number of simultaneous calls')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.5: number_of_simultaneous_users.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=25*10^6//allocated spectrum\n", +"Bc=200*10^3//channel bandwidth\n", +"Bg=0//no guard band\n", +"m=8//no. of speech channels\n", +"N=m*(Bt-2*Bg)/Bc\n", +"disp(N,'no. of simultaneous subscribers a GSM system can accommodate is ' )" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 8.7: frame_efficiency_of_GSM.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=156.25//total bits\n", +"nov=40.25//overhead bits\n", +"FReff=(1-nov/N)*100//frame efficiency\n", +"disp(FReff,'the frame efficiency (in %)')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Wireless_Communications_by_T_L_Singal/9-A_Basic_Cellular_System.ipynb b/Wireless_Communications_by_T_L_Singal/9-A_Basic_Cellular_System.ipynb new file mode 100644 index 0000000..08a36e7 --- /dev/null +++ b/Wireless_Communications_by_T_L_Singal/9-A_Basic_Cellular_System.ipynb @@ -0,0 +1,533 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 9: A Basic Cellular System" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.10: trunking_efficiency_in_sectors.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Nch=395\n", +"ncpcl=7\n", +"Pb=.01\n", +"N=Nch/ncpcl\n", +"H=3/60\n", +"Aav=44.2\n", +"Y=Aav/H\n", +"disp(Y,'average number of calls/hr. i.e(omnidirectional case) Y is')\n", +"nspc=3\n", +"Nchps=N/nspc\n", +"Aav1=11.2\n", +"avnc=Aav1/H\n", +"Y1=avnc*nspc\n", +"disp(Y1,'average number of calls/hr. ie.(3-sector case) Y is')\n", +"DTRef=(Y-Y1)/Y\n", +"disp(DTRef,'decrease in trunking efficiency')\n", +"nspc1=6\n", +"Nchps1=N/nspc1\n", +"Aav2=4.1\n", +"avnc1=Aav2/H\n", +"Y2=avnc1*nspc1\n", +"disp(Y2,'average number of calls/hr. ie.(6-sector case) Y is')\n", +"DTRef1=(Y-Y2)/Y\n", +"disp(DTRef1,'decrement in trunking efficiency')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.11: number_of_users_in_Erlang_C.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Rkm=1.4//radius of the cell\n", +"Acell=2.6*Rkm*Rkm//area (hexagonal cell)\n", +"K=4//no.of cells/cluster\n", +"ntotal=60\n", +"ncell=ntotal/K\n", +"avgtlpu=0.029\n", +"Aav=9\n", +"Pb=0.05\n", +"tnu=Aav/avgtlpu//total no. of users supported in a cell\n", +"NupA=tnu/Acell\n", +"printf('number of users per kmsqr area= %.d users/(km^2) (approx.)',NupA)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.12: number_of_users_in_FDMA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=12.5*10^6\n", +"BtMHz=12.5\n", +"Bc=30*10^3\n", +"Bg=10^3\n", +"Nt=(Bt-2*Bg)/Bc//total number of channels/cluster\n", +"Nc=21\n", +"Nd=Nt-Nc//number of user data transmission/cluster\n", +"K=7//frequency reuse factor\n", +"Ndpcell=Nd/K\n", +"Acell=6\n", +"n1=Ndpcell/(BtMHz*Acell)\n", +"disp(Nt,'total number of channels/cluster (Nt)')\n", +"disp(Nd,'number of user data transmission/cluster (Nd)')\n", +"disp(Ndpcell,'total number of transmission/cell (Nd/cell) if frequency reuse factor factor is 7 ')\n", +"disp(n1,'overall spectral efficiency n1 in channels/MHz/kmsqr for cell area 6kmsqr is ')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.13: number_of_users_in_FDMA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Acell=6\n", +"Acellular=3024\n", +"Ncells=Acellular/Acell//number of cells in the system\n", +"Bt=12.5*10^6\n", +"BtMHz=12.5\n", +"Bc=30*10^3\n", +"Bg=10*10^3\n", +"Nc=21\n", +"Nd=((Bt-2*Bg)/Bc)-Nc//no. of data channels/cluster\n", +"K=7\n", +"Ndpcell=Nd/K\n", +"H=1/20\n", +"ntr=0.95\n", +"Ncallphr=1/H\n", +"Ncallphrpcell=Ndpcell*ntr*Ncallphr//number of calls per hour per cell\n", +"Ncallpuserphr=1.5\n", +"Nusers=Ncallphrpcell/Ncallpuserphr\n", +"n1=Ndpcell/(BtMHz*Acell)\n", +"n=ntr*n1\n", +"disp(Ncells,'number of cells in the system')\n", +"disp(Ncallphrpcell,'number of calls per hour per cell')\n", +"disp(Nusers,'average number of users per hour per cell')\n", +"disp(n,'system spectral efficiency in the units of Erlangs/MHz/kmsqr')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.14: spectral_efficiency_in_TDMA.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=25*10^6//system bandwidth\n", +"Bc=30*10^3//channel bandwidth\n", +"Bg=20*10^3//guard spacing\n", +"Nu=((Bt-2*Bg)/Bc)\n", +"Tf=40*10^-3//frame time\n", +"Tp=0*10^-3//preamble time\n", +"Tt=0*10^-3//trailer time\n", +"Ld=260\n", +"Ls=324\n", +"ntframe=((Tf-Tp-Tt)/Tf)*(Ld/Ls)\n", +"ntsys=ntframe*(Nu*Bc*(1/Bt))\n", +"Rs=7.95*10^3\n", +"ntmod=Rs/Bc\n", +"K=7\n", +"nt=ntsys*ntmod/K\n", +"disp(Nu,'number of simultaneous users that can be accomodated in each cell')\n", +"disp(ntframe,'spectral efficiency per frame of a TDMA system')\n", +"disp(ntsys,'spectral efficiency of the TDMA system')\n", +"disp(nt,'overall spectral efficiency in bps/Hz/cell')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.15: radio_capacity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bc1=30*10^3;cimin1=18\n", +"Bc2=25*10^3;cimin2=14\n", +"Bc3=12.5*10^3;cimin3=12\n", +"Bc4=6.25*10^3;cimin4=9\n", +"Y=4//path propogation constant\n", +"BcI=6.25*10^3\n", +"cieq1=cimin1+20*log10(Bc1/BcI)\n", +"cieq2=cimin2+20*log10(Bc2/BcI)\n", +"cieq3=cimin3+20*log10(Bc3/BcI)\n", +"cieq4=cimin4+20*log10(Bc4/BcI)\n", +"disp(cieq1,'(C/I)eq in dB for system I')\n", +"disp(cieq2,'(C/I)eq in dB for system II')\n", +"disp(cieq3,'(C/I)eq in dB for system III')\n", +"disp(cieq4,'(C/I)eq in dB for system IV')\n", +"if cieq1<cieq2 then\n", +" if cieq1<cieq3 then\n", +" if cieq1<cieq4 then\n", +" disp(,'System I offers the best capacity')\n", +" end\n", +" end\n", +"elseif cieq2<cieq3 then\n", +" if cieq2<cieq4 then\n", +" if cieq2<cieq1 then\n", +" disp(,'System II offers the best capacity')\n", +" end\n", +" end elseif cieq3<cieq4 then\n", +" if cieq3<cieq1 then\n", +" if cieq3<cieq2 then\n", +" disp(,'System II offers the best capacity')\n", +" end \n", +" end \n", +" \n", +" elseif cieq4<cieq3 then\n", +" if cieq4<cieq1 then\n", +" if cieq4<cieq2 then\n", +" disp(,'System IV offers the best capacity')\n", +" end\n", +" end\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.16: capacity_of_GSM.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Bt=12.5*10^6\n", +"Bc=200*10^3\n", +"Ns=8\n", +"N=Bt/Bc\n", +"Ns=8\n", +"Nu=N*Ns\n", +"K=4//frequency reuse factor\n", +"SysC=Nu/K//system capacity\n", +"M=(Bt/Bc)*Ns*(1/K)//system capacity using alternate method\n", +"disp(SysC,'System capacity per cell in (users/cell)')\n", +"disp(M,'System capacity per cell,M,in (users/cell) using alternate method')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.2: average_traffic_intensity.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"n1=17;n2=16;n3=14;n4=12;n5=11;n6=10;n7=7;n8=5;n9=3;n10=2\n", +"t1=51;t2=47;t3=43;t4=39;t5=34;t6=28;t7=22;t8=15;t9=9;t10=6\n", +"tncphr=n1+n2+n3+n4+n5+n6+n7+n8+n9+n10//no. of calls/hr.\n", +"Y=tncphr/60//rate of calls/min.\n", +"toct=t1+t2+t3+t4+t5+t6+t7+t8+t9+t10//total system occupied time in min.\n", +"H=toct/tncphr//avg. holding time/call in min\n", +"Aav=Y*H\n", +"disp(Aav,'average traffic intensity Aav in Erlangs')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.3: average_traffic_per_subscriber.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Y=2//avg. no of calls/hr/user\n", +"Hmin=3\n", +"H=Hmin/60//avg. duration of a call\n", +"Aav=Y*H//average traffic intensity\n", +"disp(Aav,'average traffic intensity per user Aav in Erlangs')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.4: traffic_intensity_for_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"n1=2200;n2=1900;n3=4000;n4=1100;n5=1000;n6=1200;n7=1800;n8=2100;n9=2000;n10=1580;n11=1800;n12=900\n", +"TBW=30*10^6//total allocated bandwidth\n", +"SBW=25000//simplex channel bandwidth\n", +"NS=TBW/SBW//no.of simplex channels\n", +"DS=NS/2//no.of duplex channels\n", +"NCPC=10\n", +"NCPCL=12\n", +"TNCC=NCPC*NCPCL////no. of control channels\n", +"TNTC=DS-TNCC//no. of traffic channels\n", +"NTCPC=TNTC/NCPCL\n", +"NUPC=8\n", +"NMCPC=8\n", +"TNCPC=NMCPC*NTCPC//total no. of calls/cell\n", +"disp(TNCPC,'total no. of calls/cell')\n", +"H=5/100*3600\n", +"Y=60/3600\n", +"Aav=H*Y//traffic intensity case(b)\n", +"disp(Aav,'average offered traffic load Aav for (case(b)) in Erlangs')\n", +"tc=n1+n2+n3+n4+n5+n6+n7+n8+n9+n10+n11+n12\n", +"pbms=75/100\n", +"nbms=pbms*tc\n", +"disp(nbms,'number of mobile subscribers/cluster ')\n", +"y=tc/NCPCL\n", +"Y1=y/3600\n", +"H1=60\n", +"Aav1=Y1*H1//traffic intensity case(c)\n", +"disp(Aav1,'average offered traffic load Aav for (case(c)) in Erlangs')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.5: number_of_channels.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"Y=3000/3600\n", +"H=1.76*60\n", +"Aav=Y*H\n", +"disp(Aav,'offered traffic load Aav in Erlangs')\n", +"Pb=2/100\n", +"N=100\n", +"Y1=28000/3600\n", +"H1=105.6\n", +"Aav1=Y1*H1\n", +"N1=820\n", +"disp(N,'max. no of channels/cell')\n", +"disp(N1,'max. no of channels/cell wrt increased lambda')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.6: number_of_calls_per_hour_per_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=50//no. of channels in cell\n", +"Pb=0.02//blocking probability\n", +"Aav=40.3//offered traffic load\n", +"H=100/3600//average call-holding time\n", +"Y=Aav/H;//no. of calls handled\n", +"printf(' no. of calls handled= %.d calls/hr',Y)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.7: number_of_calls_per_hour_per_cell.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"At=0.1\n", +"Pb=0.005\n", +"N=10\n", +"Aav=3.96\n", +"Nt=Aav/At\n", +"N1=100\n", +"Aav1=80.9\n", +"Nt1=Aav1/At\n", +"disp(Nt,'total no. of mobile users')\n", +"disp(Nt1,'total no. of mobile users for increased N')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.8: number_of_users_in_Erlang_B.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N=40//no. of channels in cell\n", +"Pb=0.02//blocking probability\n", +"Aav=31//offered traffic load\n", +"H=3/60//holding time\n", +"Z=Aav/(H*3)//users per cell\n", +"NC=20//no. of cells in the system\n", +"nms=NC*Z\n", +"printf('number of mobile subscribers in the system= %.f',nms);" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.9: Trunking_efficiency.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"N1=24//no. of trunked channels\n", +"N=10//10 channels trunked together\n", +"Pb=0.01//blocking probability\n", +"Aav=4.46//offered traffic load\n", +"N2=5//2 groups of 5 trunked channels each\n", +"Aav1=1.36\n", +"Aav2=2*Aav1\n", +"Ex=Aav2/Aav//extent\n", +"if Aav>Aav2 then\n", +" disp(,'10 channels trunked together can support more traffic at a specific GOS(say 0.01) than two 5-channel trunk individually do')\n", +"else\n", +" disp(,'10 channels trunked together can support less traffic at a specific GOS(say 0.01) than two 5-channel trunk individually do')\n", +"end\n", +"printf('\nextent of more traffic supported by N=10 system as compared to two 5-channel trunked systems= %.d percent',Ex*100);" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} |