diff options
| author | hardythe1 | 2014-08-13 11:41:01 +0530 |
|---|---|---|
| committer | hardythe1 | 2014-08-13 11:41:01 +0530 |
| commit | 728bf707ac994b2cf05a32d8985d5ea27536cf34 (patch) | |
| tree | 5530b1509900ca8d6d21384e33036f50734de927 /Electronic_Communication_Systems | |
| parent | f3e94078a83634b4353ab0cd2de3b0e204a48ac7 (diff) | |
| download | Python-Textbook-Companions-728bf707ac994b2cf05a32d8985d5ea27536cf34.tar.gz Python-Textbook-Companions-728bf707ac994b2cf05a32d8985d5ea27536cf34.tar.bz2 Python-Textbook-Companions-728bf707ac994b2cf05a32d8985d5ea27536cf34.zip | |
adding book
Diffstat (limited to 'Electronic_Communication_Systems')
16 files changed, 3932 insertions, 0 deletions
diff --git a/Electronic_Communication_Systems/Chapter1.ipynb b/Electronic_Communication_Systems/Chapter1.ipynb new file mode 100755 index 00000000..0fff555e --- /dev/null +++ b/Electronic_Communication_Systems/Chapter1.ipynb @@ -0,0 +1,115 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f852f2388a309880e4ed281d6cd6695038f25edc5aca1cbeddbb1a41de15396c" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 1: Introduction to Communication Systems" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.1, page no. 10 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variable Declaration\n", + "T = 1.00*pow(10,-3) # Time (s)\n", + "Tau = 500.00*pow(10,-6) # Pulse Width (s)\n", + "A = 10.00 # Amplitude (V)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Coeff1 = A*(Tau/T) # Coefficient 1\n", + "Coeff2 = 2*A*(Tau/T)*math.sin((Tau/T)*math.pi)/((Tau/T)*math.pi) # Coefficient 2\n", + "Coeff3 = 2*A*(Tau/T)*math.sin(2*(Tau/T)*math.pi)/(2*(Tau/T)*math.pi) # Coefficient 3\n", + "Coeff4 = 2*A*(Tau/T)*math.sin(3*(Tau/T)*math.pi)/(3*(Tau/T)*math.pi) # Coefficient 4\n", + "\n", + "# Result\n", + "print \"The Coefficients of First Four Terms in the Fourier Series are:\"\n", + "print \"Coeff1 =\",round(Coeff1)\n", + "print \"Coeff2 =\",round(Coeff2,3)\n", + "print \"Coeff3 =\",round(Coeff3)\n", + "print \"Coeff4 =\",round(Coeff4,3)\n", + "print \"f(t) = [\",round(Coeff1),\"] + [\",round(Coeff2,3),\"cos(2pi*10^3*t) ] + [\",round(Coeff3),\"] + [\",round(Coeff4,3),\"cos(6pi*10^3*t)\",\"]\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Coefficients of First Four Terms in the Fourier Series are:\n", + "Coeff1 = 5.0\n", + "Coeff2 = 6.366\n", + "Coeff3 = 0.0\n", + "Coeff4 = -2.122\n", + "f(t) = [ 5.0 ] + [ 6.366 cos(2pi*10^3*t) ] + [ 0.0 ] + [ -2.122 cos(6pi*10^3*t) ]\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1.2, page no. 12 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "\n", + "# Variable Declaration\n", + "f = 0.50*pow(10,3) # First Zero Crossing (Hz)\n", + "Fw_max = 8.00*pow(10,-3) # Amplitude (V)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Tau = 1/f # Pulse Duration (s)\n", + "A = Fw_max/Tau # Maximum Voltage (V) \n", + "\n", + "# Result\n", + "print \"The single pulse has a maximum voltage of\",round(A),\"V and a duration of\",round(Tau*pow(10,3)),\"ms.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The single pulse has a maximum voltage of 4.0 V and a duration of 2.0 ms.\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter11.ipynb b/Electronic_Communication_Systems/Chapter11.ipynb new file mode 100755 index 00000000..735768b6 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter11.ipynb @@ -0,0 +1,412 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:036aa35bf5e5de2a2351f2b120a2084a8b3fc2b376331b57004e9eccc3893299" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 11: Antennas" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.1, page no. 292" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "f1 = 1.00*pow(10,6) # Operating Frequency (Hz)\n", + "f2 = 10.00*pow(10,3) # Operating Frequency (Hz)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "\n", + "# Calculation\n", + "Lambda1 = c/f1 # Mechanical Length (m)\n", + "Lambda2 = c/f2 # Mechanical Length (m)\n", + "\n", + "# Result\n", + "print \"(a) Mechanical Length at 1 MHz, Lambda1 =\",round(Lambda1),\"m\"\n", + "print \"(b) Mechanical Length at 10 kHz, Lambda2 =\",round(Lambda2),\"m\"\n", + "print \" Increase in Length =\",round(Lambda2/Lambda1),\"times\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Mechanical Length at 1 MHz, Lambda1 = 300.0 m\n", + "(b) Mechanical Length at 10 kHz, Lambda2 = 30000.0 m\n", + " Increase in Length = 100.0 times\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.2, page no. 294" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "f = 1.00*pow(10,6) # Operating Frequency (Hz)\n", + "Le = 30 # Hertzian Dipole Length (m)\n", + "I = 5 # Current value (A)\n", + "r = 1.00*pow(10,3) # Distance (m)\n", + "Theeta = 90 # Angle (degrees)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "\n", + "# Calculation\n", + "import math\n", + "Lambda = c/f # Wavelength (m)\n", + "E = ((60*math.pi*Le*I)/Lambda*r)*math.sin(Theeta*math.pi/180) # Calculation of Field Strength (s/m)\n", + "\n", + "# Result\n", + "print \"Field Strength at a distance of 1 km and at an angle of 90 degrees, E =\",round(E/(math.pi*pow(10,3))),\"*pi*10^(-3) us/m\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Field Strength at a distance of 1 km and at an angle of 90 degrees, E = 30.0 *pi*10^(-3) us/m\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.3, page no. 296" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "f = 500*pow(10,3) # Operating Frequency (Hz)\n", + "vel = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "Vf = 0.95 # Velocity Factor\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Le = vel/f*Vf # Length of the antenna (m)\n", + "\n", + "# Result\n", + "print \"The Length of the Antenna, Le =\",round(Le),\"m or\",round(Le*3.936),\"ft\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Length of the Antenna, Le = 570.0 m or 2244.0 ft\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.4, page no. 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "P1 = 1*pow(10,3) # Power of Half Wave Dipole antenna (w)\n", + "A = 2.15 # Gain (dB)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P2 = pow(10,A/10)*P1 # Power delivered (w)\n", + "\n", + "# Result\n", + "print \"The power delivered to the isotropic antenna to match the field strength of directional antenna, P2 =\",round(P2,1),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The power delivered to the isotropic antenna to match the field strength of directional antenna, P2 = 1640.6 W\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.5, page no. 300" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variable Declaration \n", + "P = 1.00*pow(10,3) # Input Power (W)\n", + "field_gain = 2 # Field Gain\n", + "E = 0.5 # (*100) Efficiency (%)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Po = P*E # Power fed (W)\n", + "erp = Po*pow(field_gain,2) # Effective Radiated Power (w)\n", + "\n", + "\n", + "# Result\n", + "print \" The Effective Radiated Power, erp =\",round(erp),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " The Effective Radiated Power, erp = 2000.0 W\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.6, page no. 300" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "P_in = 800 # Input Power (W)\n", + "E_lost = 0.25 # (*100) Loss Percentage (%)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Pd = E_lost*P_in # Power Lost (W)\n", + "P_rad = P_in-Pd # Radiated Power (W)\n", + "\n", + "# Result\n", + "print \"Radiated Power, P_rad =\",round(P_rad),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Radiated Power, P_rad = 600.0 W\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.7, page no. 301" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variable Declaration \n", + "R_rad = 100 # Radiation Resistance (Ohms)\n", + "E = 0.75 # (*100) Efficiency (%)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Rd = R_rad/E-R_rad # Antenna Resistance (Ohms)\n", + "\n", + "# Result\n", + "print \"Antenna Resistance, Rd =\",round(Rd,2),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Antenna Resistance, Rd = 33.33 Ohms\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.8, page no. 309" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "Zs = 5 # Impedance of the transmission line (Ohms)\n", + "Zr = 70 # Impedance of the antenna (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Z = Zs*Zr # Characteristic Impedance (Ohms)\n", + "\n", + "# Result\n", + "print \"The characteristic impedance of the matching section, Z =\",round(Z),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The characteristic impedance of the matching section, Z = 350.0 Ohms\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.9, page no. 316" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "D = 2 # Mouth diameter of reflector (m)\n", + "f = 6.00*pow(10,9) # Operating Frequency (Hz)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f # Wavelength (m)\n", + "phi_o = 2*70*Lambda/D # Beam width between nulls of a paraboloid reflector (degrees)\n", + "\n", + "# Result\n", + "print \"The beam width between nulls of a paraboloid reflector, phi_o =\",round(phi_o,1),\"degrees\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The beam width between nulls of a paraboloid reflector, phi_o = 3.5 degrees\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11.10, page no. 317" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration \n", + "D = 200 # Mouth diameter of reflector (m)\n", + "Lambda = 5 # Wavelength (m)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Ap = 6*pow(D/Lambda,2) # Gain of the antenna\n", + "\n", + "# Result\n", + "print \" The gain of the antenna, Ap =\",round(Ap)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " The gain of the antenna, Ap = 9600.0\n" + ] + } + ], + "prompt_number": 13 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter12.ipynb b/Electronic_Communication_Systems/Chapter12.ipynb new file mode 100755 index 00000000..37c1ea7e --- /dev/null +++ b/Electronic_Communication_Systems/Chapter12.ipynb @@ -0,0 +1,736 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:af7d5720b43a3ab91c063ac5e917869558a9550a08df4d11a5c5ce289f6c278a" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 12: Waveguides, Resonators And Components" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.1, page no. 344" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Theeta = 60 # Angle of incidence (degrees)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "vg = math.sin(Theeta*math.pi/180) # (X vc) Velocity of EM wave in parallel direction (m/S)\n", + "vn = math.cos(Theeta*math.pi/180) # (X vc) Velocity of EM wave in normal direction (m/s)\n", + "\n", + "# Result\n", + "print \"Velocity of EM wave in parallel direction, vg =\",round(vg,2),\"* vc\"\n", + "print \"Velocity of EM wave in normal direction, vn =\",round(vn,2),\"* vc\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity of EM wave in parallel direction, vg = 0.87 * vc\n", + "Velocity of EM wave in normal direction, vn = 0.5 * vc\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.2, page no. 345" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Theeta = 60 # Angle of incidence (degrees)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda_g = 1/math.sin(Theeta*math.pi/180) # (* Lambda) Wavelength of EM wave in parallel direction (m)\n", + "Lambda_n = 1/math.cos(Theeta*math.pi/180) # (* Lambda) Wavelength of EM wave in normal direction (m)\n", + "\n", + "# Result\n", + "print \"Wavelength of EM wave in parallel direction, Lambda_g =\",round(Lambda_g,2),\"* Lambda\"\n", + "print \"Wavelength of EM wave in normal direction, Lambda_n =\",round(Lambda_n,2),\"* Lambda\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Wavelength of EM wave in parallel direction, Lambda_g = 1.15 * Lambda\n", + "Wavelength of EM wave in normal direction, Lambda_n = 2.0 * Lambda\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.3, page no. 346" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Variable Declaration \n", + "Theeta = 60 # Angle of incidence (degrees)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "vp = 1/math.sin(Theeta*math.pi/180) # (* vc) Phase velocity of EM wave (m/s)\n", + "\n", + "# Result\n", + "print \"The phase velocity of EM wave, vp =\",round(vp,2),\"* vc\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The phase velocity of EM wave, vp = 1.15 * vc\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.4, page no. 349" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 5.1 # Dimension 1 of rectangular waveguide (cm)\n", + "b = 2.4 # Dimension 2 of rectangular waveguide (cm)\n", + "m = 2 # Number of half wavelengths\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = 2*a/m # Cutoff wavelength of rectangular waveguide (cm)\n", + "\n", + "# Result\n", + "print \"The cutoff wavelength of rectangular waveguide, Lambda =\",round(Lambda,1),\"cm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The cutoff wavelength of rectangular waveguide, Lambda = 5.1 cm\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.5, page no. 349" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 5.1 # Dimension 1 of rectangular waveguide (cm)\n", + "b = 2.4 # Dimension 2 of rectangular waveguide (cm)\n", + "m = 1 # Constant m for TE10 mode\n", + "n = 0 # Constant n for TE10 mode\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "fc = 1.5*pow(10,8)*math.sqrt(pow(m/a,2)+pow(n/b,2)) # Cutoff frequency of dominant mode (TE10) of rectangular waveguide (Hz)\n", + " \n", + "# Result\n", + "print \"The cutoff frequency of dominant mode (TE10) of rectangular waveguide, fc =\",round(fc/pow(10,7),2),\"GHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The cutoff frequency of dominant mode (TE10) of rectangular waveguide, fc = 2.94 GHz\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.6, page no. 350" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 5.1 # Dimension 1 of rectangular waveguide (cm)\n", + "b = 2.4 # Dimension 2 of rectangular waveguide (cm)\n", + "m1 = 0 # Constant m for TE01 mode\n", + "n1 = 1 # Constant n for TE01 mode\n", + "m2 = 2 # Constant m for TE20 mode\n", + "n2 = 0 # Constant n for TE20 mode\n", + "m3 = 0 # Constant m for TE02 mode\n", + "n3 = 2 # Constant n for TE02 mode\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "f1 = 1.5*pow(10,8)*math.sqrt(pow(m1/a,2)+pow(n1/b,2)) # Cutoff frequency of TE01 of rectangular waveguide (Hz)\n", + "f2 = 1.5*pow(10,8)*math.sqrt(pow(m2/a,2)+pow(n2/b,2)) # Cutoff frequency of TE20 of rectangular waveguide (Hz)\n", + "f3 = 1.5*pow(10,8)*math.sqrt(pow(m3/a,2)+pow(n3/b,2)) # Cutoff frequency of TE02 of rectangular waveguide (Hz)\n", + "\n", + "# Result\n", + "print \"The frequency of TE01 mode of rectangular waveguide, f1 =\",round(f1/pow(10,7),2),\"GHz\"\n", + "print \"The frequency of TE20 mode of rectangular waveguide, f2 =\",round(f2/pow(10,7),2),\"GHz\"\n", + "print \"The frequency of TE02 mode of rectangular waveguide, f3 =\",round(f3/pow(10,7),2),\"GHz\"\n", + "print \"Hence the lowest frequency except dominant mode is, f =\",round(min(f1,f2,f3)/pow(10,7),2),\"GHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The frequency of TE01 mode of rectangular waveguide, f1 = 6.25 GHz\n", + "The frequency of TE20 mode of rectangular waveguide, f2 = 5.88 GHz\n", + "The frequency of TE02 mode of rectangular waveguide, f3 = 12.5 GHz\n", + "Hence the lowest frequency except dominant mode is, f = 5.88 GHz\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.7, page no. 351" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 3.00 # Plane Separation of rectangular waveguide (cm)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "f = 6.00*pow(10,9) # Operating frequency (Hz)\n", + "m = 1.00 # Constant m for dominant mode\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f * 100 # Operating Wavelength (cm)\n", + "Lambda_o = 2*a/m # Cutoff Wavelength (cm)\n", + "Lambda_p = Lambda/math.sqrt(1-pow(Lambda/Lambda_o,2)) # Guide Wavelength (cm)\n", + "vg = c*math.sqrt(1-pow(Lambda/Lambda_o,2)) # Group velocity (m/s)\n", + "vp = c/math.sqrt(1-pow(Lambda/Lambda_o,2)) # Phase velocity (m/s)\n", + "\n", + "# Result\n", + "print \"(a) Cutoff Wavelength, Lambda_o =\",round(Lambda_o),\"cm\"\n", + "print \"(b) Guide Wavelength, Lambda_p =\",round(Lambda_p,2),\"cm\"\n", + "print \"(c) Group Velocity, vg =\",round(vg/pow(10,8),2),\"*10^(8) m/s\"\n", + "print \" Phase Velocity, vp =\",round(vp/pow(10,8),2),\"*10^(8) m/s\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Cutoff Wavelength, Lambda_o = 6.0 cm\n", + "(b) Guide Wavelength, Lambda_p = 9.05 cm\n", + "(c) Group Velocity, vg = 1.66 *10^(8) m/s\n", + " Phase Velocity, vp = 5.43 *10^(8) m/s\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.8, page no. 352" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 6.00 # Plane Separation of rectangular waveguide (cm)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "f = 10.00*pow(10,9) # Operating frequency (Hz)\n", + "m1 = 1# Dimensional Constant\n", + "m2 = 2# Dimensional Constant\n", + "m3 = 3# Dimensional Constant\n", + "m4 = 4# Dimensional Constant\n", + "\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f * 100 # Operating Wavelength (cm)\n", + "Lambda_o1 = 2*a/m1 # Wavelength (cm)\n", + "Lambda_o2 = 2*a/m2 # Wavelength (cm)\n", + "Lambda_o3 = 2*a/m3 # Wavelength (cm)\n", + "Lambda_o4 = 2*a/m4 # Wavelength (cm)\n", + "Lambda_p = Lambda/math.sqrt(1-pow(Lambda/Lambda_o3,2)) # Guide Wavelength (cm)\n", + "\n", + "# Result\n", + "print \"(a) For m = 1, Lambda_o =\",round(Lambda_o1),\"cm\"\n", + "print \" For m = 2, Lambda_o =\",round(Lambda_o2),\"cm\"\n", + "print \" For m = 3, Lambda_o =\",round(Lambda_o3),\"cm\"\n", + "print \" For m = 4, Lambda_o =\",round(Lambda_o4),\"cm\"\n", + "print \" Hence The largest value of m = 3\"\n", + "print \"(b) Guide Wavelength, Lambda_p =\",round(Lambda_p,2),\"cm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) For m = 1, Lambda_o = 12.0 cm\n", + " For m = 2, Lambda_o = 6.0 cm\n", + " For m = 3, Lambda_o = 4.0 cm\n", + " For m = 4, Lambda_o = 3.0 cm\n", + " Hence The largest value of m = 3\n", + "(b) Guide Wavelength, Lambda_p = 4.54 cm\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.9, page no. 354" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Lambda = 2.00 # Wavelength of travelling wave (cm)\n", + "Lambda_o = 4.00 # Cutoff wavelength (cm)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Zo = 377/math.sqrt(1-pow(Lambda/Lambda_o,2)) # Characteristic impedance of the given waveguide (Ohms)\n", + "\n", + "# Result\n", + "print \"The characteristic impedance of the given waveguide, Zo =\",round(Zo),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The characteristic impedance of the given waveguide, Zo = 435.0 Ohms\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.10, page no. 355" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "\n", + "# Variable Declaration\n", + "m = 1 # Constant m for TM11 mode\n", + "n = 1 # Constant n for TM11 mode\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda_o = 2/math.sqrt(pow(m,2)+pow(2*n,2)) # (* a) Cutoff wavelength with b=a/2 (m)\n", + "\n", + "# Result\n", + "print \"Cutoff wavelength of standard rectangular waveguides, Lambda_o =\",round(Lambda_o,3),\"* a \"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Cutoff wavelength of standard rectangular waveguides, Lambda_o = 0.894 * a \n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.11, page no. 356" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "rho1 = 0.553 # Constant from Example 12.7\n", + "rho2 = 0.661 # Constant from Example 12.8\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Zo1 = 120*math.pi/rho1 # Characteristic Wave Impedance (Ohms)\n", + "Zo2 = 120*math.pi/rho2 # Characteristic Wave Impedance (Ohms)\n", + "\n", + "# Result\n", + "print \"Ex.12.7 : Characteristic Wave Impedance, Zo1 =\",round(Zo1),\"Ohms\"\n", + "print \"Ex.12.8 : Characteristic Wave Impedance, Zo2 =\",round(Zo2),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Ex.12.7 : Characteristic Wave Impedance, Zo1 = 682.0 Ohms\n", + "Ex.12.8 : Characteristic Wave Impedance, Zo2 = 570.0 Ohms\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.12, page no. 357" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 4.5 # Dimension 1 of rectangular waveguide (cm)\n", + "b = 3.0 # Dimension 2 of rectangular waveguide (cm)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "f = 9.00*pow(10,9) # Operating frequency (Hz)\n", + "m1 = 1 # Constant m for TE10 mode\n", + "n1 = 0 # Constant n for TE10 mode\n", + "m2 = 1 # Constant m for TM11 mode\n", + "n2 = 1 # Constant n for TM11 mode\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f * 100 # Operating Wavelength (cm)\n", + "Lambda_o1 = 2*a/m1 # Cutoff Wavelength (cm)\n", + "Lambda_p1 = Lambda/math.sqrt(1-pow(Lambda/Lambda_o1,2)) # Guide Wavelength (cm)\n", + "vg1 = c*math.sqrt(1-pow(Lambda/Lambda_o1,2)) # Group velocity (m/s)\n", + "vp1 = c/math.sqrt(1-pow(Lambda/Lambda_o1,2)) # Phase velocity (m/s)\n", + "Zo1 = 120*math.pi/math.sqrt(1-pow(Lambda/Lambda_o1,2)) # Characteristic Wave Impedance (Ohms)\n", + "Lambda_o2 = 2/math.sqrt(pow(m2/a,2)+pow(n2/b,2))\t # Cutoff Wavelength (cm)\n", + "Lambda_p2 = Lambda/math.sqrt(1-pow(Lambda/Lambda_o2,2))\t # Guide Wavelength (cm)\n", + "vg2 = c*math.sqrt(1-pow(Lambda/Lambda_o2,2))\t # Group velocity (m/s)\n", + "vp2 = c/math.sqrt(1-pow(Lambda/Lambda_o2,2))\t # Phase velocity (m/s)\n", + "Zo2 = 120*math.pi*math.sqrt(1-pow(Lambda/Lambda_o2,2)) # Characteristic Wave Impedance (Ohms)\n", + "\n", + "# Result\n", + "print \"(a) For TE10 mode :\"\n", + "print \"Cutoff Wavelength, Lambda_o =\",round(Lambda_o1),\"cm\"\n", + "print \"Guide Wavelength, Lambda_p =\",round(Lambda_p1,2),\"cm\"\n", + "print \"Group Velocity, vg =\",round(vg1/pow(10,8),2),\"*10^(8) m/s\"\n", + "print \"Phase Velocity, vp =\",round(vp1/pow(10,8),2),\"*10^(8) m/s\"\n", + "print \"Characteristic Wave Impedance, Zo =\",round(Zo1,1),\"Ohms\"\n", + "print \"(b) For TM11 mode :\"\n", + "print \"Cutoff Wavelength, Lambda_o =\",round(Lambda_o2),\"cm\"\n", + "print \"Guide Wavelength, Lambda_p =\",round(Lambda_p2,1),\"cm\"\n", + "print \"Group Velocity, vg =\",round(vg2/pow(10,8),2),\"*10^(8) m/s\"\n", + "print \"Phase Velocity, vp =\",round(vp2/pow(10,8),2),\"*10^(8) m/s\"\n", + "print \"Characteristic Wave Impedance, Zo =\",round(Zo2),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) For TE10 mode :\n", + "Cutoff Wavelength, Lambda_o = 9.0 cm\n", + "Guide Wavelength, Lambda_p = 3.59 cm\n", + "Group Velocity, vg = 2.79 *10^(8) m/s\n", + "Phase Velocity, vp = 3.23 *10^(8) m/s\n", + "Characteristic Wave Impedance, Zo = 405.9 Ohms\n", + "(b) For TM11 mode :\n", + "Cutoff Wavelength, Lambda_o = 5.0 cm\n", + "Guide Wavelength, Lambda_p = 4.5 cm\n", + "Group Velocity, vg = 2.23 *10^(8) m/s\n", + "Phase Velocity, vp = 4.03 *10^(8) m/s\n", + "Characteristic Wave Impedance, Zo = 281.0 Ohms\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.13, page no. 357" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "a = 3 # Width of rectangular waveguide (cm)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "m = 1 # Constant m for dominant mode\n", + "Zo = 500 # Characteristic wave impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda_o = 2*a/m # Cutoff Wavelength (cm)\n", + "Lambda = pow(1-pow(120*math.pi/Zo,2),0.5)*Lambda_o # Operating wavelength (cm)\n", + "f = c/Lambda # Operating Frequency (Hz)\n", + " \n", + "# Result\n", + "print \"Operating Frequency, f =\",round(f/pow(10,7),2),\"GHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Operating Frequency, f = 7.61 GHz\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.14, page no. 360" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Example 12.14\n", + "# Calculate the cutoff wavelength,\n", + "\n", + "# Variable Declaration\n", + "r = 2.00 # Diameter of circular waveguide (cm)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "f = 10.00*pow(10,9) # Operating frequency (Hz)\n", + "kr = 1.84 # Constant from Table 12.2\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f * 100 # Operating Wavelength (cm)\n", + "Lambda_o = 2*math.pi*r/kr # Cutoff Wavelength (cm)\n", + "Lambda_p = Lambda/math.sqrt(1-pow(Lambda/Lambda_o,2)) # Guide Wavelength (cm)\n", + "Zo = 120*math.pi/math.sqrt(1-pow(Lambda/Lambda_o,2)) # Characteristic Wave Impedance (Ohms)\n", + "\n", + "# Result\n", + "print \"Cutoff Wavelength, Lambda_o =\",round(Lambda_o,2),\"cm\"\n", + "print \"Guide Wavelength, Lambda_p =\",round(Lambda_p,2),\"cm\"\n", + "print \"Characteristic Wave Impedance, Zo =\",round(Zo),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Cutoff Wavelength, Lambda_o = 6.83 cm\n", + "Guide Wavelength, Lambda_p = 3.34 cm\n", + "Characteristic Wave Impedance, Zo = 420.0 Ohms\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.15, page no. 361" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Variable Declaration\n", + "r = 1 # Diameter(assumption) of circular waveguide (cm)\n", + "m = 1 # Constant m for dominant mode\n", + "kr = 1.84 # Constant from Table 12.2\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda_o1 = 2*math.pi*r/kr # Cutoff Wavelength for circular waveguide (cm)\n", + "Lambda_o2 = Lambda_o1 # Cutoff Wavelength for rectangular waveguide (cm)\n", + "a = Lambda_o2*m/2 # Dimensional Variable\n", + "Ac = math.pi*pow(r,2) # Cross Sectional Area of Circular Waveguide (m^2)\n", + "Ar = pow(a,2)/2 # Cross Sectional Area of Rectangular Waveguide (m^2)\n", + "R \t = Ac/Ar # Ratio\n", + " \n", + "# Result\n", + "print \"Ratio, Ac/Ar =\",round(R,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Ratio, Ac/Ar = 2.16\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12.16, page no. 378" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Variable Declaration\n", + "a = 1.00 # Dimension 1 of rectangular waveguide (cm)\n", + "b = 0.50 # Dimension 2 of rectangular waveguide (cm)\n", + "m = 1 # Constant m for dominant mode\n", + "del1 = 25.00 # Length of waveguide (cm)\n", + "c = 3.00*pow(10,8)# Speed of light in vacuum (m/s) \n", + "f = 1.00*pow(10,9)# Operating frequency (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda_o = 2 * a/m # Cutoff Wavelength (cm)\n", + "Lambda = c/f * 100 # Operating Wavelength (cm)\n", + "A_dB = 54.5 * del1/Lambda_o # Voltage attenuation of waveguide in dominant mode (dB)\n", + "\n", + "# Result\n", + "if Lambda_o<Lambda : print \"The waveguide is operating below cutoff\"\n", + "print \"Voltage attenuation of waveguide in dominant mode, A_dB =\",round(A_dB),\"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The waveguide is operating below cutoff\n", + "Voltage attenuation of waveguide in dominant mode, A_dB = 681.0 dB\n" + ] + } + ], + "prompt_number": 36 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter15.ipynb b/Electronic_Communication_Systems/Chapter15.ipynb new file mode 100755 index 00000000..7a578c06 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter15.ipynb @@ -0,0 +1,400 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f82338b15d5e32b80b8782ce45f00e7b56a16efde942696b5a56c79c32e5fe3b" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 15: Radar Systems" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.1, page no. 485" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "PW = 3.00*pow(10,-6) # Pulse Width (s)\n", + "PRT = 6.00*pow(10,-3) # Pulse Repetition Time (s)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "DS = PW/PRT # Duty Cycle\n", + "\n", + "# Result\n", + "print \"Duty Cycle =\",round(DS,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Duty Cycle = 0.0005\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.2, page no. 485" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "PW = 3.00*pow(10,-6) # Pulse Width (s)\n", + "PP = 100.00*pow(10,3) # Peak Power (W)\n", + "RT = 1997.00 # Rest Time (s)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "DS = 1/RT # Duty Cycle\n", + "AP = PP*DS # Average Power (W)\n", + "\n", + "# Result\n", + "print \"Average Power =\",round(AP),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average Power = 50.0 W\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.3, page no. 490" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "NF = 9.00 # Noise Figure (dB)\n", + "k = 1.38*pow(10,-23) # Boltzmann's Constant (J/K)\n", + "del_f = 1.50*pow(10,6) # Receiver Band Width (Hz)\n", + "To = 290 # Standard Ambient temperature (K)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "F = pow(10,NF/10) # Noise Figure\n", + "P_min = k*To*del_f*(F-1) # Minimum receivable signal in a Radar Receiver (W)\n", + "\n", + "# Result\n", + "print \"Minimum receivable signal in the Radar Receiver, P_min =\",round(P_min/pow(10,-14),2),\"* 10^(-14) W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum receivable signal in the Radar Receiver, P_min = 4.17 * 10^(-14) W\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.4, page no. 490" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Pt = 5.00*pow(10,5) # Peak Pulse Power (W)\n", + "Lambda = 3.00*pow(10,-2) # Wavelength (m)\n", + "P_min = 1.00*pow(10,-13) # Minimum receivable Power (W)\n", + "Ao = 5# Capture Area of Antenna (m^2)\n", + "S = 20 # Radar Cross-sectional Area (m^2)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "r_max = pow(Pt*pow(Ao,2)*S/(4*math.pi*pow(Lambda,2)*P_min),0.25)\n", + " # Maximum range of the Radar System (m)\n", + "# Result\n", + "print \"Maximum range of the Radar System, r_max =\",round(r_max/1000),\"km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum range of the Radar System, r_max = 686.0 km\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.5, page no. 490" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "F_dB = 4.77 # Noise Figure (dB)\n", + "f = 8.00*pow(10,9) # Operating Frequency (Hz)\n", + "c = 3.00*pow(10,8) # Speed of light in vacuum (m/s)\n", + "del_f = 5.00*pow(10,5) # IF Bandwidth (Hz)\n", + "rmax = 12.00 # Maximum distance (km)\n", + "D = 1.00 # Antenna Diameter (m)\n", + "S = 5.00 # Cross sectional area (m^2)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f # Wavelength (m)\n", + "F = pow(10,F_dB/10) # Noise Figure\n", + "Pt = del_f*pow(Lambda,2)*(F-1)/(pow(48/rmax,4)*pow(D,4)*S) # Peak transmitted pulse power (W)\n", + "\n", + "# Result\n", + "print \"The peak transmitted pulse power, Pt =\",round(Pt,1),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The peak transmitted pulse power, Pt = 1.1 W\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.6, page no. 500" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "f = 2.50*pow(10,9) # Radar Operating Frequency (Hz)\n", + "c = 3.00*pow(10,8) # Velocity of light in vacuum (m/s)\n", + "Pt = 25.00*pow(10,6) # Peak Pulse Power (W)\n", + "D = 64.00 # Antenna Diameter (m)\n", + "F = 1.1 # Receiver Noise Figure\n", + "S = 1.00 # Radar Cross-sectional Area (m^2)\n", + "del_f = 5.00*pow(10,3) # Receiver Bandwidth (Hz)\n", + "\n", + "# Calculation\n", + "import math# Math Library\n", + "Lambda = c/f# Wavelength (m)\n", + "r_max = 48*pow(Pt*pow(D,4)*S/(del_f*pow(Lambda,2)*(F-1)),0.25)\n", + "# Maximum range of the Radar System (km)\n", + "# Result\n", + "print \"Maximum range of the Radar System, r_max =\",round(r_max),\"km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum range of the Radar System, r_max = 132609.0 km\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.7, page no. 504" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "v_c = 3.00*pow(10,8) # Velocity of light in vacuum (m/s)\n", + "f = 5.00*pow(10,9) # MTI radar Transmit Frequency (Hz)\n", + "PRF = 800 # Pulse Repetition Frequency (pps)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = v_c/f # Wavelength(m)\n", + "vb1 = PRF*Lambda*60*60*pow(10,-3) # Blind Speed in for n=1 (km/h)\n", + "vb2 = 2*PRF*Lambda*60*60*pow(10,-3) # Blind Speed in for n=2 (km/h)\n", + "vb3 = 3*PRF*Lambda*60*60*pow(10,-3) # Blind Speed in for n=3 (km/h)\n", + "\n", + "# Result\n", + "print \"Lowest three blind speeds will be\",round(vb1,1),\",\",round(vb2,1),\"and\",round(vb3,1),\"km/h\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Lowest three blind speeds will be 172.8 , 345.6 and 518.4 km/h\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.8, page no. 506" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "# Variable Declaration\n", + "F_dB = 13 # Noise Figure of beacon (dB)\n", + "Ft = 1.1 # Noise Figure of system\n", + "f = 2.50*pow(10,9) # Operating Frequency (Hz)\n", + "D = 64 # Antenna Diameter (m)\n", + "Db = 1 # Antenna Diameter of beacon (m)\n", + "del_f = 5.00*pow(10,3) # Bandwidth (Hz)\n", + "Ptt = 0.50*pow(10,6) # Peak Pulse power (W)\n", + "Ptb = 50 # Peak Pulse power of beacon (W)\n", + "k = 1.38*pow(10,-23) # Boltzman's Constant (J/K)\n", + "c = 3.00*pow(10,8) # Speed of light in vaccum (m/s)\n", + "To = 290 # Temperature (K)\n", + "\n", + "# Calculation\n", + "import math# Math Library\n", + "Aot = 0.65*math.pi*pow(D,2)/4# Capture Area (m^2)\n", + "Aob = 0.65*math.pi*pow(Db,2)/4# Capture Area (m^2)\n", + "Lambda = c/f# Wavelength (m)\n", + "Fb = pow(10,F_dB/10)# Noise Figure\n", + "rmax_I = pow(Aot*Ptt*Aob/(pow(Lambda,2)*k*To*del_f*(Fb-1)),0.5)\n", + "# Maximum range for the interrogation link (m)\n", + "rmax_R = pow(Aob*Ptb*Aot/(pow(Lambda,2)*k*To*del_f*(Ft-1)),0.5)\n", + "# Maximum range for the reply link (m)\n", + "\n", + "# Result\n", + "print \"The Maximum Tracking Range, Rmax =\",round(min(rmax_I/pow(10,10),rmax_R/pow(10,10))),\"million km\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Maximum Tracking Range, Rmax = 136.0 million km\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15.9, page no. 507" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "c = 3.00*pow(10,8) # Velocity of light in vacuum (m/s)\n", + "f = 5.00*pow(10,9) # CW Transmit Frequency (Hz)\n", + "v = 100.00 # Target Speed (km/h)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Lambda = c/f # Wavelength (m)\n", + "vr = v*1000/(60*60) # Target Speed (m/s)\n", + "f_d = 2*vr/Lambda # Doppler frequency (Hz)\n", + "\n", + "# Result\n", + "print \"Doppler frequency, f_d =\",round(f_d),\"Hz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Doppler frequency, f_d = 926.0 Hz\n" + ] + } + ], + "prompt_number": 26 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter17.ipynb b/Electronic_Communication_Systems/Chapter17.ipynb new file mode 100755 index 00000000..d337b75e --- /dev/null +++ b/Electronic_Communication_Systems/Chapter17.ipynb @@ -0,0 +1,140 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:a213742fda8c74130f9501f7775b062f79302454ea874815627cdc7db481bf9e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 17: Introduction To Fiber Optic Technology" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.1, page no. 557" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "n1 = 1.50 # Refractive Index of Substance 1\n", + "n2 = 1.46 # Refractive Index of Substance 2\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "THEETA_c = math.asin(n2/n1) # Critical angle of incidence (degrees)\n", + "\n", + "# Result\n", + "print \"The critical angle of incidence between two given substances is THEETA_c =\",round(THEETA_c*180/math.pi,1),\"degrees.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The critical angle of incidence between two given substances is THEETA_c = 76.7 degrees.\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17.2, page no. 566" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "tr = 2.00*pow(10,-9) # Rise Time (s)\n", + "Cd = 3.00*pow(10,-12) # Capacitance (F)\n", + "Cdh = 2.00*pow(10,-12) # Assumed Capacitance (F)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "BW = 0.35/tr # Bandwidth (Hz)\n", + "Rl = 1/(2*math.pi*BW*Cdh) # Resistance (Ohms)\n", + "\n", + "# Result\n", + "print \"BW =\",round(BW/pow(10,6)),\"MHz\"\n", + "print \"Rl =\",round(Rl),\"Ohms\"\n", + "print \"In practice, a value approximately 25 percent of this calculated value will be used.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "BW = 175.0 MHz\n", + "Rl = 455.0 Ohms\n", + "In practice, a value approximately 25 percent of this calculated value will be used.\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 17.3, page no. 569" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Mu_A = 40.00 # Diode Current (uW)\n", + "Mu_W = 80.00 # Incident Light (uW)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "R = Mu_A/Mu_W # Responsivity (A/W)\n", + "\n", + "# Result\n", + "print \"The Responsivity of the light detector is R =\",round(R,1),\"A/W.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The Responsivity of the light detector is R = 0.5 A/W.\n" + ] + } + ], + "prompt_number": 12 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter18.ipynb b/Electronic_Communication_Systems/Chapter18.ipynb new file mode 100755 index 00000000..b9594307 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter18.ipynb @@ -0,0 +1,107 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:b47d42851a95b239c1a54b9b998eec602c81d678d0f92705fab117d580600a10" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 18: Information Theory, Coding And Data Communication" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 18.1, page no. 591" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "SNR_dB = 32.00 # Signal to Noise ratio (dB)\n", + "f1 = 300.00 # Lower Limit of Voice Frequency (Hz)\n", + "f2 = 3400.0 # Upper Limit of Voice Frequency (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "SNR = pow(10,SNR_dB/10) # Signal to Noise Ratio\n", + "C = (f2-f1)*math.log(1+SNR,2) # Capacity of Telephone Channel (bps)\n", + "\n", + "# Result\n", + "print \"The capacity of a standard 4 kHz telephone channel with 32 dB SNR is C =\",round(C,1),\"bits per second.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The capacity of a standard 4 kHz telephone channel with 32 dB SNR is C = 32956.3 bits per second.\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 18.2, page no. 591" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "SNR_dB = 28.00 \t # Signal to Noise ratio (dB)\n", + "BW1 = 4.00*pow(10,3) # System Bandwidth 1 (Hz)\n", + "BW2 = 8.00*pow(10,3) # System Bandwidth 2 (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "SNR1 = pow(10,SNR_dB/10) # Signal to Noise Ratio 1\n", + "C1 = BW1*math.log(1+SNR1,2) # Information Carrying Capacity (bps)\n", + "SNR2 = pow(10,SNR_dB/10)/2 # Signal to Noise Ratio 2\n", + "C2 = BW2*math.log(1+SNR2,2) # Information Carrying Capacity (bps)\n", + "\n", + "# Result\n", + "print \"(a) The information carrying capacity of a standard 4 kHz telephone channel with 28 dB SNR is C1 =\",round(C1),\"bits per second.\"\n", + "print \"(b) The information carrying capacity of a standard 8 kHz telephone channel with same signal power as in (a) is C2 =\",round(C2),\"bits per second.\"\n", + "print \" Also the ratio of the two quantities, C2/C1 =\",round(C2/C1,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) The information carrying capacity of a standard 4 kHz telephone channel with 28 dB SNR is C1 = 37215.0 bits per second.\n", + "(b) The information carrying capacity of a standard 8 kHz telephone channel with same signal power as in (a) is C2 = 66448.0 bits per second.\n", + " Also the ratio of the two quantities, C2/C1 = 1.786\n" + ] + } + ], + "prompt_number": 5 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter2.ipynb b/Electronic_Communication_Systems/Chapter2.ipynb new file mode 100755 index 00000000..03040c32 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter2.ipynb @@ -0,0 +1,266 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:7e1c74a28912b449959296d5be17e181689de7baeff58aa5e2dcd8837dc4f405" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 2: Noise" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.1, page no. 18" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "del_f = 2.00*pow(10,6) # Bandwidth of interest (Hz)\n", + "T = 300 # Operating Temperature (K)\n", + "k = 1.38*pow(10,-23) # Boltzmann's Constant (J/K)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Pn = k*T*del_f # Power Output (W)\n", + "\n", + "# Result\n", + "print \"Maximum noise power output of the resistor, Pn =\",round(Pn/pow(10,-13),4),\"* 10^(-13) Watts\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum noise power output of the resistor, Pn = 0.0828 * 10^(-13) Watts\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.2, page no. 19" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "del_f = 2.00*pow(10,6) # Bandwidth of interest (Hz)\n", + "T = 300 # Operating Temperature (K)\n", + "k = 1.38*pow(10,-23) # Boltzmann's Constant (J/K)\n", + "R = 10.00*pow(10,3) # Input Resistance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Vn = pow(4*k*T*del_f*R,0.5) # RMS Noise Voltage (V)\n", + "\n", + "# Result\n", + "print \"The rms noise voltage at the input of the amplifier, Vn =\",round(Vn/pow(10,-6),1),\"microvolts\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The rms noise voltage at the input of the amplifier, Vn = 18.2 microvolts\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.3, page no. 21" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "del_f = 6.00*pow(10,6) # Bandwidth of interest (Hz)\n", + "T = 290 # Operating Temperature (K)\n", + "k = 1.38*pow(10,-23) # Boltzmann's Constant (J/K)\n", + "R1 = 300 # Input Resistance (Ohms)\n", + "R2 = 200 # Device Resistance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Vn = pow(4*k*T*del_f*(R1+R2),0.5) # Noise voltage (V)\n", + "\n", + "# Result\n", + "print \"The noise voltage at the input of the Television RF amplifier, Vn =\",round(Vn/pow(10,-6),2),\"uV\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The noise voltage at the input of the Television RF amplifier, Vn = 6.93 uV\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.4, page no. 23" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "A1 = 10 # First Stage Voltage Gain\n", + "A2 = 25 # Second Stage Voltage Gain\n", + "R11 = 600 # First Stage Resistance (Ohms)\n", + "R12 = 1600 # First Stage Resistance (Ohms)\n", + "R21 = 27000 # Second Stage Resistance (Ohms)\n", + "R22 = 81000 # Second Stage Resistance (Ohms)\n", + "R23 = 10000 # Second Stage Resistance (Ohms)\n", + "R3 = 1.00*pow(10,6) # Third Stage Resistance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "R1 = R11+R12 # Resistance 1 (Ohms)\n", + "R2 = R21*R22/(R21+R22)+R23 # Resistance 2 (Ohms)\n", + "Req = R1+(R2/pow(A1,2))+R3/((A1*A1)*(A2*A2)) # Input Noise Resistance (Ohms)\n", + "\n", + "# Result\n", + "print \"Input Noise Resistance, Req =\",round(Req),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Input Noise Resistance, Req = 2518.0 Ohms\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.5, page no. 28" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Req = 2518.00 # Resistance From Example 2.4 (Ohms)\n", + "Rt = 600.00 # Resistance From Example 2.4 (Ohms)\n", + "Ra = 50.00 # Output Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Req1 = Req-Rt # Equivalent Resistance (Ohms)\n", + "NF = 1+Req1/Ra # Noise Figure\n", + "\n", + "# Result\n", + "print \"Noise Figure, F =\",round(NF,1),\"or\",round(10*math.log10(NF),2),\"dB\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Noise Figure, F = 39.4 or 15.95 dB\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.6, page no. 29" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "To = 290 # Operating Temperature (K)\n", + "Ra = 50.00 # Antenna Resistance (Ohms)\n", + "Req = 30.00 # Equivalent Noise Resistance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "NF = 1+Req/Ra # Noise Figure\n", + "F = 10*math.log10(NF) # Noise Figure (dB)\n", + "Teq = To*(NF-1) # Noise Temperature (K)\n", + " \n", + "# Result\n", + "print \"Noise Figure, F =\",round(F,2),\"dB\"\n", + "print \"Noise Temperature, Teq =\",round(Teq),\"K\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Noise Figure, F = 2.04 dB\n", + "Noise Temperature, Teq = 174.0 K\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter3.ipynb b/Electronic_Communication_Systems/Chapter3.ipynb new file mode 100755 index 00000000..3e0faa39 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter3.ipynb @@ -0,0 +1,581 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:e528d450b010e6a0fc0701d08e663db71f95558ee29c88e64def041726f96bfa" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3: Amplitude Modulation Techniques" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.1, page no. 36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "L = 50.0*pow(10,-6) # Transmitter Inductance (H)\n", + "C = 1.0*pow(10,-9) # Transmitter Capacitance (F)\n", + "AF_range = 10*pow(10,3) # Audio Frequency Range (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "fc= 1/(2*math.pi*math.sqrt(L*C))# Center Frequency (Hz)\n", + "fl= fc-AF_range# Frequency of LSB (Hz)\n", + "fu= fc+AF_range# Frequency of USB (Hz)\n", + "\n", + "# Result\n", + "print \"Center Frequency, fc= \",math.ceil(fc/pow(10,3)),\"kHz\"\n", + "print \"Frequency Range occupied by the Sidebands is\",math.ceil(fl/pow(10,3)),\"to\",math.ceil(fu/pow(10,3)),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Center Frequency, fc= 712.0 kHz\n", + "Frequency Range occupied by the Sidebands is 702.0 to 722.0 kHz\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.2, page no. 38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_c = 400 # Carrier Power (W)\n", + "m = 0.75 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P_AM = P_c*(1+pow(m,2)/2) # Total Power in the modulated Wave (W)\n", + "\n", + "# Result\n", + "print \"Total Power in the Modulated Wave is\",P_AM,\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total Power in the Modulated Wave is 512.5 W\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.3, page no. 39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_t = 10000 # Radio Transmitter Power (W)\n", + "m = 0.60 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P_c = P_t/(1+pow(m,2)/2) # Carrier Power (W)\n", + "\n", + "# Result\n", + "print \"Carrier Power is\",round(P_c/pow(10,3),2),\"kW\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Carrier Power is 8.47 kW\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.4, page no. 39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "I_t = 8.93 # Total Antenna current (A) \n", + "I_c = 8 # Carrier Antenna Current (A)\n", + "m = 0.80 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "m1 = math.sqrt(2*(pow(I_t/I_c,2)-1)) # Percentage Modulation (%)\n", + "I_t1 = I_c*math.sqrt(1+pow(m,2)/2) # Antenna Current (A)\n", + "\n", + "# Result\n", + "print \"Modulation Index calculated for first part is\",round(m1*100,1),\"%\"\n", + "print \"Antenna Current calculated for second part is\",round(I_t1,2),\"A\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Modulation Index calculated for first part is 70.1 %\n", + "Antenna Current calculated for second part is 9.19 A\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.5, page no. 41\u00b6" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_t = 10.125*pow(10,3) # Total Power(W)\n", + "P_c = 9.00*pow(10,3) # Carrier Power(W)\n", + "m2 = 0.40 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "m1 = math.sqrt(2*(P_t/P_c-1)) # Modulation Index\n", + "mt = math.sqrt(pow(m1,2)+pow(m2,2)) # Total Modulation index\n", + "P_AM = P_c*(1+pow(mt,2)/2) # Total Radiated Power(W)\n", + "\n", + "# Result\n", + "print \"Modulation Index of first part is, m =\",m1\n", + "print \"Total Modulation Index is, m_t =\",round(mt,2)\n", + "print \"Total Radiated Power, P_AM =\",P_AM/pow(10,3),\"kW\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Modulation Index of first part is, m = 0.5\n", + "Total Modulation Index is, m_t = 0.64\n", + "Total Radiated Power, P_AM = 10.845 kW\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.6, page no. 41" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "I_t = 11 # Total Antenna current (A) \n", + "I_T = 12 # Total Antenna current for second part (A) \n", + "m1 = 0.40 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "I_c = I_t/math.sqrt(1+pow(m1,2)/2) # Current (A)\n", + "mt = math.sqrt(2*(pow(I_T/I_c,2)-1)) # Modulation Index\n", + "m2 = math.sqrt(pow(mt,2)-pow(m1,2)) # Modulation Index\n", + "\n", + "# Result\n", + "print \"Modulation Index calculated is\",round(m2,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Modulation Index calculated is 0.64\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.7, page no. 44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_c = 400 # Carrier Power (W)\n", + "m1 = 1.0 # Modulation Index (for first part)\n", + "m2 = 0.75 # Modulation Index (for second part)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "# (i) Power saving of DSBSC compared to AM for 100% Modulation Depth\n", + "P_AM1=P_c*(1+pow(m1,2)/2) # Power of AM Wave (W)\n", + "P_DSBSC1=P_c*pow(m1,2)/2 # Power of DSBSC Wave (W)\n", + "Saving1=P_AM1-P_DSBSC1 # Power Saving (W)\n", + "# (ii) Power Required for DSBSC Wave Transmission for 75% Modulation Depth\n", + "P_DSBSC2=P_c*pow(m2,2)/2 # Power of DSBSC Wave (W)\n", + "\n", + "# Result\n", + "print \"(i) Power of AM Wave for\",m1*100,\"% Modulation Depth is\",P_AM1,\"W\"\n", + "print \" Power of DSBSC Wave for\",m1*100,\"% Modulation Depth is\",P_DSBSC1,\"W\"\n", + "print \" Power saving of DSBSC compared to AM for\",m1*100,\"% Modulation Depth is\",Saving1,\"W\"\n", + "print \"(ii) Power Required for DSBSC Wave Transmission for\",m2*100,\"% Modulation Depth is\",P_DSBSC2,\"W\"\n", + "print \" Power of DSBSC is maximum for m = 1, and less for m < 1.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Power of AM Wave for 100.0 % Modulation Depth is 600.0 W\n", + " Power of DSBSC Wave for 100.0 % Modulation Depth is 200.0 W\n", + " Power saving of DSBSC compared to AM for 100.0 % Modulation Depth is 400.0 W\n", + "(ii) Power Required for DSBSC Wave Transmission for 75.0 % Modulation Depth is 112.5 W\n", + " Power of DSBSC is maximum for m = 1, and less for m < 1.\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.8, page no. 45" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_DSBSC = 1000 # Total Power (W)\n", + "m = 0.60 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P_c = P_DSBSC*(2/pow(m,2)) # Carrier Power (W)\n", + "\n", + "# Result\n", + "print \"We require\",round(P_c/pow(10,3),2),\"kW to transmit the carrier component along with the existing\",P_DSBSC/pow(10,3),\" kW for the sidebands.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "We require 5.56 kW to transmit the carrier component along with the existing 1 kW for the sidebands.\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.9, page no.48" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_c = 400 # Carrier Power (W)\n", + "m1 = 1.0 # Modulation Index (for first part)\n", + "m2 = 0.75 # Modulation Index (for second part)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "# (i) Power saving of SSB compared to AM AND DSBSC for 100% Modulation Depth\n", + "P_AM1 = P_c*(1+pow(m1,2)/2) # Power of AM Wave (w)\n", + "P_DSBSC1 = P_c*pow(m1,2)/2 # Power of DSBSC Wave (w)\n", + "P_SSB1 = P_c*pow(m1,2)/4 # Power of SSB Wave (w)\n", + "Saving1 = P_AM1-P_SSB1 # Power Saving (w)\n", + "Saving2 = P_DSBSC1-P_SSB1 # Power Saving (w)\n", + "# (ii) Power Required for SSB Wave Transmission for 75% Modulation Depth\n", + "P_SSB2 = P_c*pow(m2,2)/4 # Power of SSB Wave (w)\n", + "\n", + "# Result\n", + "\n", + "print \"(i) Power of SSB Wave for\",m1*100,\"% Modulation Depth is\",P_SSB1,\"W\"\n", + "print \" Power saving of SSB compared to AM for\",m1*100,\"% Modulation Depth is\",Saving1,\"W and compared to DSBSC for\",m1*100,\"% Modulation Depth is\",Saving2,\"W\"\n", + "print \"(ii) Power Required for SSB Wave Transmission for\",m2*100,\"% Modulation Depth is\",P_SSB2,\"W\"\n", + "print \" Power of SSB is maximum for m = 1, and less for m < 1.\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Power of SSB Wave for 100.0 % Modulation Depth is 100.0 W\n", + " Power saving of SSB compared to AM for 100.0 % Modulation Depth is 500.0 W and compared to DSBSC for 100.0 % Modulation Depth is 100.0 W\n", + "(ii) Power Required for SSB Wave Transmission for 75.0 % Modulation Depth is 56.25 W\n", + " Power of SSB is maximum for m = 1, and less for m < 1.\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.10, page no. 49\u00b6" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_SSB = 0.5*pow(10,3) # Total Power (W)\n", + "m = 0.60 # Modulation Index\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P_c = P_SSB*(4/pow(m,2)) # Carrier Power (W)\n", + "\n", + "# Result\n", + "print \"We require\",round(P_c/pow(10,3),2),\"kW to transmit the carrier component along with the existing\",P_SSB/pow(10,3),\"kW for the one sideband and\",1-P_SSB/pow(10,3),\"kW more for another sideband.\"\n", + "print \"In Total\",round(P_c/pow(10,3)+1,2),\"kW is required by the AM Transmitter\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "We require 5.56 kW to transmit the carrier component along with the existing 0.5 kW for the one sideband and 0.5 kW more for another sideband.\n", + "In Total 6.56 kW is required by the AM Transmitter\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.11, page no. 49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "m1 = 1.0 # Modulation Index for (a)\n", + "m2 = 0.5 # Modulation Index for (b)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "# (a) Percentage Power Saving for Depth of Modulation 100 %\n", + "PAM_by_Pc1 = 1+pow(m1,2)/2 # Ratio of AM Wave to Carrier Power (W)\n", + "PSSB_By_Pc1 = pow(m1,2)/4 # Ratio of SSB Wave to Carrier Power (W)\n", + "Saving1 = (PAM_by_Pc1-PSSB_By_Pc1)/PAM_by_Pc1 # Power Saving (W)\n", + "# (b) Percentage Power Saving for Depth of Modulation 50 %\n", + "PAM_by_Pc2 = 1+pow(m2,2)/2 # Ratio of AM Wave to Carrier Power (W)\n", + "PSSB_By_Pc2 = pow(m2,2)/4 # Ratio of SSB Wave to Carrier Power (W)\n", + "Saving2 = (PAM_by_Pc2-PSSB_By_Pc2)/PAM_by_Pc2 # Power Saving (W)\n", + "\n", + "# Result\n", + "print \"(a)Percentage Power Saving for Depth of Modulation of\",m1,\"is\",round(Saving1*100,1),\"%\"\n", + "print \"(b)Percentage Power Saving for Depth of Modulation of\",m2,\"is\",round(Saving2*100,1),\"%\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)Percentage Power Saving for Depth of Modulation of 1.0 is 83.3 %\n", + "(b)Percentage Power Saving for Depth of Modulation of 0.5 is 94.4 %\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.12, page no. 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_c = 400 # Carrier Power (W)\n", + "m1 = 1.0 # Modulation Index (for first part)\n", + "m2 = 0.75 # Modulation Index (for second part)\n", + "x = 0.2 # (*100)Percentage Wanted Sideband in VSB (%)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "# (i) Power saving of VSB compared to AM, DSBSC and SSB for 100% Modulation Depth\n", + "P_AM1 = P_c*(1+pow(m1,2)/2) # Power of AM Wave (W)\n", + "P_DSBSC1 = P_c*pow(m1,2)/2 # Power of DSBSC Wave (W) \n", + "P_SSB1 = P_c*pow(m1,2)/4 # Power of SSB Wave (W)\n", + "P_VSB1 = P_c*pow(m1,2)/4+x*P_c*pow(m1,2)/4 # Power of VSB Wave (W)\n", + "Saving1 = P_AM1-P_VSB1 # Power Saving (W)\n", + "Saving2 = P_DSBSC1-P_VSB1 # Power Saving (W)\n", + "Saving3 = P_VSB1-P_SSB1 # Power Saving (W)\n", + "# (ii) Power Required for VSB Wave Transmission for 75% Modulation Depth\n", + "P_VSB2 = P_c*pow(m2,2)/4+x*P_c*pow(m2,2)/4 # Power of VSB Wave (W)\n", + "\n", + "# Result\n", + "print \"(i) Power Required for VSB Wave Transmission for\",m1*100,\"% Modulation Depth is\",P_VSB1,\"W\"\n", + "print \" Power saving of VSB compared to AM for\",m1*100,\"% Modulation Depth is\",Saving1,\"W and compared to DSBSC for\",m1*100,\"% Modulation Depth is\",Saving2,\"W and compared to SSB for\",m1*100,\"% Modulation Depth is\",Saving3,\"W\"\n", + "print \"(ii) Power Required for VSB Wave Transmission for\",m2*100,\"% Modulation Depth is\",P_VSB2,\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(i) Power Required for VSB Wave Transmission for 100.0 % Modulation Depth is 120.0 W\n", + " Power saving of VSB compared to AM for 100.0 % Modulation Depth is 480.0 W and compared to DSBSC for 100.0 % Modulation Depth is 80.0 W and compared to SSB for 100.0 % Modulation Depth is 20.0 W\n", + "(ii) Power Required for VSB Wave Transmission for 75.0 % Modulation Depth is 67.5 W\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.13, page no. 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "P_VSB = 0.625*pow(10,3) # Total Power (W)\n", + "m = 0.60 # Modulation Index\n", + "x = 0.25 # (*100) Percentage Power Transmitted of other Sideband (%)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "P_c = P_VSB*(4/((1+x)*pow(m,2))) # Carrier Power (W)\n", + "\n", + "# Result\n", + "print \"We require\",round(P_c/pow(10,3),2),\"kW to transmit the carrier component along with the existing\",P_VSB/pow(10,3),\"kW for the one sideband and\",1-P_VSB/pow(10,3),\"kW more for rest of the other sidebands.\"\n", + "print \"In Total\",round(P_c/pow(10,3)+1,2),\"kW is required by AM Transmitter\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "We require 5.56 kW to transmit the carrier component along with the existing 0.625 kW for the one sideband and 0.375 kW more for rest of the other sidebands.\n", + "In Total 6.56 kW is required by AM Transmitter\n" + ] + } + ], + "prompt_number": 13 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter4.ipynb b/Electronic_Communication_Systems/Chapter4.ipynb new file mode 100755 index 00000000..be889b2d --- /dev/null +++ b/Electronic_Communication_Systems/Chapter4.ipynb @@ -0,0 +1,460 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:82b1a87e5b1e62f448481647ab7f0e2ca7607ff780f8775431ec8c2b250882dc" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4: Angle Modulation Techniques" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1, page no. 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "# Variable Declaration\n", + "fm1 = 500 # Audio Frequency (Hz)\n", + "Vm1 = 2.4 # AF Voltage (V)\n", + "del_f1 = 4.8*pow(10,3) # Deviation (Hz)\n", + "fm2 = 500 # Audio Frequency (Hz)\n", + "Vm2 = 7.2 # AF Voltage (V)\n", + "fm3 = 200 # Audio Frequency (Hz)\n", + "Vm3 = 10 # AF Voltage (V)\n", + "\n", + "# Calculation\n", + "import math\t # Math Library\n", + "kf = del_f1/Vm1 # Proportionality Constant\n", + "mf1 = del_f1/fm1 # Modulation Index\n", + "del_f2 = kf*Vm2 # Deviation (Hz)\n", + "mf2 = del_f2/fm2 # Modulation Index\n", + "del_f3 = kf*Vm3 # Deviation (Hz)\n", + "mf3 = del_f3/fm3 # Modulation Index\n", + " \n", + "# Result\n", + "\n", + "print \"CASE 1 : Modulation Index, mf1 =\",round(mf1,1)\n", + "print \" Deviation, del_f1 =\",round(del_f1/pow(10,3),1),\"kHz\"\n", + "print \"CASE 2 : Modulation Index, mf2 =\",round(mf2,1)\n", + "print \" Deviation, del_f2 =\",round(del_f2/pow(10,3),1),\"kHz\"\n", + "print \"CASE 3 : Modulation Index, mf3 =\",round(mf3)\n", + "print \" Deviation, del_f3 =\",round(del_f3/pow(10,3),1),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "CASE 1 : Modulation Index, mf1 = 9.6\n", + " Deviation, del_f1 = 4.8 kHz\n", + "CASE 2 : Modulation Index, mf2 = 28.8\n", + " Deviation, del_f2 = 14.4 kHz\n", + "CASE 3 : Modulation Index, mf3 = 100.0\n", + " Deviation, del_f3 = 20.0 kHz\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2, page no. 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "# GIVEN EXPRESSION : v = 12 sin(6 X 10^(8)t + 5 cos(1250t))\n", + "omega1 = 6.00*pow(10,8) # Angular Velocity (rad/s)\n", + "omega2 = 1250 # Angular Velocity (rad/s)\n", + "mf = 5 # Modulation Index\n", + "A = 12 # Amplitude (V)\n", + "R = 10 # Resistance (Ohms)\n", + "\n", + "# Calculation\n", + "import math\t # Math Library\n", + "fc = omega1/(2*math.pi) # Carrier frequency (Hz)\n", + "fm = omega2/(2*math.pi) # Modulating frequency (Hz)\n", + "del_f = mf*fm # Maximum deviation (Hz)\n", + "P = pow(A/math.sqrt(2),2)/R # Power dissipation (w)\n", + "\n", + "# Result\n", + "print \"Carrier frequency, fc =\",round(fc/pow(10,6),1),\" MHz\"\n", + "print \"Modulating frequency, fm =\",round(fm),\" Hz\"\n", + "print \"Modulation Index, mf =\",round(mf)\n", + "print \"Maximum deviation, del_f =\",round(del_f),\"Hz\"\n", + "print \"Power dissipation, P =\",round(P,1),\"W\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Carrier frequency, fc = 95.5 MHz\n", + "Modulating frequency, fm = 199.0 Hz\n", + "Modulation Index, mf = 5.0\n", + "Maximum deviation, del_f = 995.0 Hz\n", + "Power dissipation, P = 7.2 W\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3, page no. 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "fm1 = 500 # Audio Frequency (Hz)\n", + "Vm1 = 2.4 # AF Voltage (V)\n", + "del_p1 = 4.8 # Deviation (kHz)\n", + "fm2 = 500 # Audio Frequency (Hz)\n", + "Vm2 = 7.2 # AF Voltage (V)\n", + "fm3 = 200 # Audio Frequency (Hz)\n", + "Vm3 = 10 # AF Voltage (V)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "kp = del_p1/Vm1 # Proportionality Constant\n", + "mp1 = del_p1 # Modulation Index\n", + "del_p2 = kp*Vm2 # Deviation (kHz)\n", + "mp2 = del_p2 # Modulation Index\n", + "del_p3 = kp*Vm3 # Deviation (kHz)\n", + "mp3 = del_p3 # Modulation Index\n", + " \n", + "# Result\n", + "print \"CASE 1 : Modulation Index, mp1 =\",round(mp1,1)\n", + "print \" Deviation, del_p1 =\",round(del_p1,1),\"kHz\"\n", + "print \"CASE 2 : Modulation Index, mp2 =\",round(mp2,1)\n", + "print \" Deviation, del_p2 =\",round(del_p2,1),\"kHz\"\n", + "print \"CASE 3 : Modulation Index, mp3 =\",round(mp3)\n", + "print \" Deviation, del_p3 =\",round(del_p3,1),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "CASE 1 : Modulation Index, mp1 = 4.8\n", + " Deviation, del_p1 = 4.8 kHz\n", + "CASE 2 : Modulation Index, mp2 = 14.4\n", + " Deviation, del_p2 = 14.4 kHz\n", + "CASE 3 : Modulation Index, mp3 = 20.0\n", + " Deviation, del_p3 = 20.0 kHz\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4, page no. 74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "# GIVEN EXPRESSION : v = 12 sin(6 X 10^(8)t + 5 cos(1250t))\n", + "omega1 = 6*pow(10,8) # Angular Velocity (rad/s)\n", + "omega2 = 1250 # Angular Velocity (rad/s)\n", + "mp = 5 # Modulation Index\n", + "A = 12 # Amplitude (V)\n", + "\n", + "# Calculation\n", + "import math\t # Math Library\n", + "fc = omega1/(2*math.pi) # Carrier frequency (Hz)\n", + "fm = omega2/(2*math.pi) # Modulating frequency (Hz)\n", + "del_p = mp # Maximum Deviation (kHz)\n", + "\n", + "# Result\n", + "print \"Carrier frequency, fc =\",round(fc/pow(10,6),1),\" MHz\"\n", + "print \"Modulating frequency, fm =\",round(fm),\" Hz\"\n", + "print \"Modulation Index, mp =\",round(mp),\"radians\"\n", + "print \"Maximum deviation, del_p =\",round(del_p),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Carrier frequency, fc = 95.5 MHz\n", + "Modulating frequency, fm = 199.0 Hz\n", + "Modulation Index, mp = 5.0 radians\n", + "Maximum deviation, del_p = 5.0 kHz\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5, page no. 75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "# GIVEN EXPRESSION FM: v=A sin(omega_c*t + mf cos(omega_m*t))\n", + "# GIVEN EXPRESSION PM: v=A sin(omega_c*t + mp cos(omega_m*t))\n", + "A = 4 # Carrier Voltage (V)\n", + "del_f = 10.00*pow(10,3) # Maximum Frequency Deviation (Hz)\n", + "del_p = 25 # Maximum Phase Deviation (Hz)\n", + "f_c = 25.00*pow(10,6) # Carrier Frequency (Hz)\n", + "f_m1 = 400 # Modulating Frequency 1 (Hz)\n", + "f_m2 = 2000 # Modulating Frequency 2 (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "omega_c = 2*math.pi*f_c # Angular Velocity of carrier (rad/s)\n", + "omega_m = 2*math.pi*f_m1 # Angular Velocity of Modulating Wave (rad/s)\n", + "mf1 = del_f/f_m1 # Modulation Index for FM\n", + "mf2 = del_f/f_m2 # Modulation Index for FM\n", + "mp = del_p # Modulation Index for PM\n", + "\n", + "# Result\n", + "print \"(a)For FM Case 1, v =\",round(A),\"sin(\",round(omega_c/pow(10,8),2),\"* 10^(8) * t +\",round(mf1),\"cos\",round(omega_m),\"* t )\"\n", + "print \"(b)For PM Case 1, v =\",round(A),\"sin(\",round(omega_c/pow(10,8),2),\"* 10^(8) * t +\",round(mp),\"cos\",round(omega_m),\"* t )\"\n", + "print \"(c)For FM Case 2, v =\",round(A),\"sin(\",round(omega_c/pow(10,8),2),\"* 10^(8) * t +\",round(mf2),\"cos\",round(omega_m),\"* t )\"\n", + "print \"(d)For PM Case 2, v =\",round(A),\"sin(\",round(omega_c/pow(10,8),2),\"* 10^(8) * t +\",round(mp),\"cos\",round(omega_m),\"* t )\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)For FM Case 1, v = 4.0 sin( 1.57 * 10^(8) * t + 25.0 cos 2513.0 * t )\n", + "(b)For PM Case 1, v = 4.0 sin( 1.57 * 10^(8) * t + 25.0 cos 2513.0 * t )\n", + "(c)For FM Case 2, v = 4.0 sin( 1.57 * 10^(8) * t + 5.0 cos 2513.0 * t )\n", + "(d)For PM Case 2, v = 4.0 sin( 1.57 * 10^(8) * t + 25.0 cos 2513.0 * t )\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.6, page no. 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "del1 = 10.00*pow(10,3) # Maximum Deviation (Hz)\n", + "fm = 2.00*pow(10,3) # Modulating frequency (Hz)\n", + "H = 8 # Highest Needed Sideband from Table 4.1\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "mf = del1/fm # Modulation Index\n", + "delta = fm*H*2 # Bandwidth required for the FM signal (Hz)\n", + "\n", + "# Result\n", + "print \"Bandwidth required for the FM signal, delta =\",round(delta/pow(10,3)),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Bandwidth required for the FM signal, delta = 32.0 kHz\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.7, page no. 88" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "gm = 12.00* pow(10,-3) # Transconductance (Siemens) \n", + "f = 5.00*pow(10,6) # Frequency (Hz)\n", + "n = 9 # Constant, from X_GS = (1/9)X_GD\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "XCeq = n/gm # Capacitive Reactance of the FET (Ohms)\n", + "\n", + "# Result\n", + "print \"Capacitive reactance of the FET, XCeq =\",round(XCeq),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitive reactance of the FET, XCeq = 750.0 Ohms\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.8, page no. 89" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "gm = 9.00*pow(10,-3) # Transconductance (Siemens) \n", + "f = 50.00*pow(10,6) # Frequency (Hz)\n", + "n = 8 # Constant, from R_GS = (1/8)XC_GD\n", + "C = 50.00*pow(10,-12) # Capacitance (F)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Cn = 0 # Minimum Equivalent Capacitance of FET (F)\n", + "Cx = gm/(2*math.pi*f*n) # Maximum Equivalent Capacitance of FET (F)\n", + "fx_by_fn = math.sqrt(1+Cx/C) # Maximum to Minimum Frequency Ratio\n", + "delta = (fx_by_fn-1)*f/(fx_by_fn+1) # Total frequency variation of FET (Hz)\n", + "\n", + "# Result\n", + "print \"Total frequency variation of FET =\",round(2*delta/pow(10,6),2),\"MHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total frequency variation of FET = 1.73 MHz\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.9, page no. 90" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "gm_max = 830.00*pow(10,-6) # Max. Transconductance (Siemens)\n", + "gm_min = 320.00*pow(10,-6) # Min. Transconductance (Siemens) \n", + "f = 88.00*pow(10,6) # Frequency (Hz)\n", + "n = 10 # Constant, from R_GS = (1/10)XC_GD\n", + "delta = 75*pow(10,3) # Maximum Deviation (Hz)\n", + "Vgs1 = -2 # Gate Source Voltage (V)\n", + "Vgs2 = -0.5 # Gate Source Voltage (V)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Vm_rms = -(Vgs1-Vgs2)/(2*math.sqrt(2)) # RMS value of required voltage modulating voltage (V)\n", + "Cn = gm_min/(2*math.pi*f*n) # Minimum Equivalent Capacitance of FET (F)\n", + "Cx = Cn*gm_max/gm_min # Maximum Equivalent Capacitance of FET (F)\n", + "C = (Cx-Cn)*f/(4*delta)-Cn # Capacitance (F)\n", + "L = 1/(4*pow(math.pi*f,2)*C) # Inductance (H)\n", + "\n", + "# Result\n", + "print \"(a) RMS value of required modulating voltage, Vm_rms =\",round(Vm_rms,2),\"V\"\n", + "print \"(b) Capacitance, C =\",round(C/pow(10,-12)),\"pF\"\n", + "print \" Inductance, L =\",round(L/pow(10,-6),3),\"uH\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) RMS value of required modulating voltage, Vm_rms = 0.53 V\n", + "(b) Capacitance, C = 27.0 pF\n", + " Inductance, L = 0.121 uH\n" + ] + } + ], + "prompt_number": 9 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter5.ipynb b/Electronic_Communication_Systems/Chapter5.ipynb new file mode 100755 index 00000000..c71801d8 --- /dev/null +++ b/Electronic_Communication_Systems/Chapter5.ipynb @@ -0,0 +1,98 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:41db786e06a01c332ebd11f188e721e6640c124416532b39896420ba483ab6cd" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5: Pulse Modulation Techniques " + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.1, page no. 107" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "F_m = 4.00*pow(10,3) # Maximum Frequency Component in Message Signal (Hz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "F_s = 2*F_m\t # Minimum Sampling Frequency using Sampling Theorem (Hz)\n", + "\n", + "# Result\n", + "print \"F_s >=(greater than or equal to)\",F_s/pow(10,3),\"kHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "F_s >=(greater than or equal to) 8.0 kHz\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.2, page no. 107" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "F1 = 500 # Single Tone Sine Wave Frequency in Message Signal (Hz)\n", + "F2 = 750 # Lowest Value Sound Frequency in Message Signal (Hz)\n", + "F3 = 1800 # Highest Value Sound Frequency in Message Signal (Hz)\n", + "\n", + "# Calculation\n", + "import math\t # Math Library\n", + "F_m = max(F1,F2,F3) # Maximum Frequency Component (Hz)\n", + "F_s = 2*F_m\t # Minimum Sampling Frequency using Sampling Theorem (Hz)\n", + "\n", + "# Result\n", + "print \"F_s >=(greater than or equal to)\",F_s,\"Hz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "F_s >=(greater than or equal to) 3600 Hz\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter7.ipynb b/Electronic_Communication_Systems/Chapter7.ipynb new file mode 100755 index 00000000..1d5a897b --- /dev/null +++ b/Electronic_Communication_Systems/Chapter7.ipynb @@ -0,0 +1,164 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:cd13dfdb6dd7420874a1c992512f922297a6fa769a755d9c2c04bb32f02bdf3a" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 7: Radio Transmitters and Receivers " + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.1, page no. 153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "fs1 = 1.00*pow(10,6) # Sampling Frequency (Hz)\n", + "fs2 = 25.00*pow(10,6) # Sampling Frequency (Hz)\n", + "fi = 455.00*pow(10,3) # Intermediate Frequency (Hz)\n", + "Q = 100.00 # Loaded Q of the antenna coupling circuit \n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "fsi1 = fs1+2*fi # Image Frequency (Hz)\n", + "rho1 = fsi1/fs1-fs1/fsi1 # Constant 1\n", + "alpha1 = math.sqrt(1+pow(Q*rho1,2)) # Rejection Ratio 1\n", + "fsi2 = fs2+2*fi # Image Frequency (Hz) \n", + "rho2 = fsi2/fs2-fs2/fsi2 # Constant 2\n", + "alpha2 = math.sqrt(1+pow(Q*rho2,2)) # Rejection Ratio 2\n", + "\n", + "# Result\n", + "print \"(a) Image Frequency, fsi =\",fsi1/pow(10,3),\"kHz\"\n", + "print \" rho =\",round(rho1,3)\n", + "print \" Image Rejection, Alpha =\",round(alpha1,1)\n", + "print \"(b) Image Frequency, fsi =\",fsi2/pow(10,6),\"MHz\"\n", + "print \" rho =\",round(rho2,4)\n", + "print \" Image Rejection, Alpha =\",round(alpha2,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Image Frequency, fsi = 1910.0 kHz\n", + " rho = 1.386\n", + " Image Rejection, Alpha = 138.6\n", + "(b) Image Frequency, fsi = 25.91 MHz\n", + " rho = 0.0715\n", + " Image Rejection, Alpha = 7.22\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.2, page no. 153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "alpha1 = 138.6 # Image Rejection From Example 7.1\n", + "alpha2 = 7.22 # Image Rejection From Example 7.1\n", + "rho = 0.0715 # Constant From Example 7.1\n", + "Q = 100.00 # Loaded Q From Example 7.1\n", + "fsi_dash = 1.91*pow(10,6) # Image Frequency (Hz)\n", + "fs_dash = 1.00*pow(10,6) # Sampling Frequency 1 (Hz)\n", + "fs = 25.00*pow(10,6) # Sampling Frequency 2 (Hz)\n", + "\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Q_dash = math.sqrt(pow(alpha1/alpha2,2)-1)/rho # Loaded Q of the RF amplifier\n", + "fi_dash = (fsi_dash/fs_dash*fs-fs)/2 # Intermediate Frequency (Hz) \n", + "\n", + "# Result\n", + "print \"(a) The Q of the circuit is\",round(math.sqrt(Q*Q_dash)),\", which is the geometric mean of\",round(Q),\"and\",round(Q_dash)\n", + "print \"(b) Intermediate Frequency, fi_dash =\",round(fi_dash/pow(10,6),1),\"MHz\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) The Q of the circuit is 164.0 , which is the geometric mean of 100.0 and 268.0\n", + "(b) Intermediate Frequency, fi_dash = 11.4 MHz\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7.3, page no. 164" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "R1 = 110.00*pow(10,3) # RESISTANCE 1 (Ohms)\n", + "R2 = 220.00*pow(10,3) # RESISTANCE 2 (Ohms)\n", + "R3 = 470.00*pow(10,3) # RESISTANCE 3 (Ohms)\n", + "R4 = 1.00*pow(10,6) # RESISTANCE 4 (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Rc = R1+R2 # Resistance (Ohm)\n", + "Zm = R2*R3*R4/(R2*R3+R3*R4+R2*R4)+R1 # Impedance (Ohm)\n", + "m_max = Zm/Rc # Maximum Modulation Index\n", + "\n", + "# Result\n", + "print \"Maximum Modulation Index, m_max =\",round(m_max*pow(10,2)),\"%\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum Modulation Index, m_max = 73.0 %\n" + ] + } + ], + "prompt_number": 4 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/Chapter9.ipynb b/Electronic_Communication_Systems/Chapter9.ipynb new file mode 100755 index 00000000..41eca70b --- /dev/null +++ b/Electronic_Communication_Systems/Chapter9.ipynb @@ -0,0 +1,443 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:c4970c321276b9f7170413d941bf292098cec215a7f4a0308f53e52cf40aad5c" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 9: Transmission Lines" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.1, page no. 237" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Zo = 75 # Characteristic Impedance (Ohms) \n", + "C = 69.00*pow(10,-12) # Nominal Capacitance (F/m)\n", + "Di = 0.584*pow(10,-3) # Inner core diameter (m)\n", + "k = 2.23 # Dielectric Constant\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "L = pow(Zo,2)*C # Inductance per meter (H/m)\n", + "Do = Di*pow(10,Zo*math.sqrt(k)/138) # Outer core diameter (m)\n", + "\n", + "# Result\n", + "print \"Inductance per meter, L =\",round(L/pow(10,-6),3),\"uH/m\"\n", + "print \"Outer Diameter, D =\",round(Do/pow(10,-3),2),\"mm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per meter, L = 0.388 uH/m\n", + "Outer Diameter, D = 3.78 mm\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.2, page no. 237" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "s = 1 # Assumed s (m)\n", + "d = s # Condition for minimum Zo (m)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Zo_min = 276*math.log10(2*s/d) # Minimum value of characteristic impedance (Ohms)\n", + " \n", + "# Result\n", + "print \"The minimum value of characteristic impedance, Zo_min =\",round(Zo_min),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The minimum value of characteristic impedance, Zo_min = 83.0 Ohms\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.3, page no. 237" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Zo = 2000 # Characteristic Impedance (Ohms) \n", + "Di = 0.025*pow(10,-3) # Inner cable diameter (m)\n", + "k = 2.56 # Dielectric Constant \n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Do = Di*pow(10,Zo*math.sqrt(k)/138) # Outer conductor diameter (m)\n", + "\n", + "# Result\n", + "print \"Outer Diameter, D =\",round(Do/pow(10,18),2),\"* 10^(15) km or\",round(Do/(9.44*pow(10,15))),\"light years\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Outer Diameter, D = 3.86 * 10^(15) km or 409.0 light years\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.4, page no. 243" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Zo = 200 # Characteristic Impedance of main line (Ohms) \n", + "Zl = 300 # Load Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Zo1 = math.sqrt(Zo*Zl) # Characteristic impedance of the quarter wave transformer (Ohms)\n", + "\n", + "# Result\n", + "print \"Characteristic impedance of the quarter wave transformer, Zo1 =\",round(Zo1),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Characteristic impedance of the quarter wave transformer, Zo1 = 245.0 Ohms\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.5, page no. 246" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Zl = complex(200,75) # Load Impedance (Ohms)\n", + "Zo = 300 # Characteristic Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "Yl = 1/Zl # Admittance (Mho)\n", + "Bstub = 1/Yl.imag # Reactance of the Stub (Ohms)\n", + "Gl = Yl.real # Real Part of Admittance (Mho)\n", + "Rl = 1/Gl # Resistance (Ohms)\n", + "Zo1 = math.sqrt(Zo*Rl) # Characteristic impedance of the quarter wave transformer (Ohms)\n", + "\n", + "# Result\n", + "print \"Reactance of the stub, Bstub =\",round(Bstub,1),\"Ohms\"\n", + "print \"Characteristic impedance of the quarter wave transformer, Zo1 =\",round(Zo1),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reactance of the stub, Bstub = -608.3 Ohms\n", + "Characteristic impedance of the quarter wave transformer, Zo1 = 262.0 Ohms\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.6, page no. 250" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Y = complex(0.004,0.002) # Load Susceptance (Ohms)\n", + "Yo = 0.0033 # Ohms - Characteristic Admittance (Ohms)\n", + "f = 150*pow(10,6) # Operating Frequency (Hz)\n", + "vc = 3*pow(10,8) # Speed of light in vacuum (m/s)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "y = Y/Yo # Normalized susceptance required to cancel loads normalized susceptance\n", + "Lambda = vc/f # Wavelength (m)\n", + "Length = 0.337*Lambda # Length from Smith Chart (m)\n", + "\n", + "# Result\n", + "print \"Normalized susceptance required to cancel loads normalized susceptance = +j *\",round(y.imag,2)\n", + "print \"Length =\",round(Length*100,1),\"cm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Normalized susceptance required to cancel loads normalized susceptance = +j * 0.61\n", + "Length = 67.4 cm\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.7, page no. 250" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Z = complex(100,50) # Load Impedance (Ohms)\n", + "Zo = 75 # Characteristic Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "z = Z/Zo # Normalized Load Impedance (Ohms)\n", + "Zg = 39.8 # Resistance at Distance = 0.184* Lambda, from Smith Chart (Ohms)\n", + "Zo_dash = math.sqrt(Zg*Zo) # Impedance of the transformer (Ohms)\n", + "\n", + "# Result\n", + "print \"(a) From Smith Chart the Distance = 0.184 * Lambda\"\n", + "print \"(b) Zo_dash for the transformer, Zo' =\",round(Zo_dash,1),\"Ohms\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) From Smith Chart the Distance = 0.184 * Lambda\n", + "(b) Zo_dash for the transformer, Zo' = 54.6 Ohms\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.8, page no. 253" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Z = complex(450,-600) # Load Impedance (Ohms)\n", + "Zo = 300 # Characteristic Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "z = Z/Zo # Normalized Load Impedance (Ohms)\n", + "s = 4.6 # Standing Wave Ratio\n", + "L = 1/(2*math.pi)*math.atan(math.sqrt(s)/(s-1)) # (* Lambda) Stub Length (m)\n", + "\n", + "# Result\n", + "print \"Normalized load Impedance = \",z\n", + "print \"From Smith Chart the Distance to the stub = 0.130 * Lambda\"\n", + "print \"Stub Length =\",round(L,3),\"* Lambda\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Normalized load Impedance = (1.5-2j)\n", + "From Smith Chart the Distance to the stub = 0.130 * Lambda\n", + "Stub Length = 0.086 * Lambda\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.9, page no. 254" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Z = complex(450,-600) # Load Impedance (Ohms)\n", + "Zo = 300 # Characteristic Impedance (Ohms)\n", + "f1 = 10 # Old frequency (MHz)\n", + "f2 = 12 # New frequency (MHz)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "z = Z/Zo # Normalized Load Impedance (Ohms)\n", + "z1 = z.imag * f1/f2 # Intermediate Impedance (Ohms)\n", + "z = complex(z.real,z1) # Normalized Load Impedance (Ohms)\n", + "s = 4.6 # Standing Wave Ratio\n", + "L = 1/(2*math.pi)*math.atan(math.sqrt(s)/(s-1))*f2/f1 # (* Lambda')Stub Length (m)\n", + "\n", + "# Result\n", + "print \"Normalized load Impedance = \",z\n", + "print \"From Smith Chart the Distance to the stub = 0.156 * Lambda'\"\n", + "print \"Stub Length =\",round(L,3),\"* Lambda'\"\n", + "print \"From Smith chart SWR = 2.2\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Normalized load Impedance = (1.5-1.66666666667j)\n", + "From Smith Chart the Distance to the stub = 0.156 * Lambda'\n", + "Stub Length = 0.103 * Lambda'\n", + "From Smith chart SWR = 2.2\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9.10, page no. 256" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Variable Declaration\n", + "Z = 200.00 # Load Impedance (Ohms)\n", + "Zo = 300.00 # Characteristic Impedance (Ohms)\n", + "\n", + "# Calculation\n", + "import math # Math Library\n", + "z = Z/Zo # Normalized Load Impedance (Ohms)\n", + "L1_by_Lambda = 0.311 # Ratio from Smith Chart\n", + "L2_by_Lambda1 = L1_by_Lambda*1.1 # Ratio\n", + "\n", + "# Result\n", + "print \"(a) Normalized load Impedance = \",round(z,2)\n", + "print \" From Smith Chart the Distance to the stub = 0.11 * Lambda\"\n", + "print \" From Smith Chart the Length of stub = 0.311 * Lambda\"\n", + "print \"(b) New Length of stub =\",round(L2_by_Lambda1,3),\"* Lambda'\"\n", + "print \" From Smith chart SWR = 1.3\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Normalized load Impedance = 0.67\n", + " From Smith Chart the Distance to the stub = 0.11 * Lambda\n", + " From Smith Chart the Length of stub = 0.311 * Lambda\n", + "(b) New Length of stub = 0.342 * Lambda'\n", + " From Smith chart SWR = 1.3\n" + ] + } + ], + "prompt_number": 11 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electronic_Communication_Systems/README.txt b/Electronic_Communication_Systems/README.txt new file mode 100755 index 00000000..b681cbb1 --- /dev/null +++ b/Electronic_Communication_Systems/README.txt @@ -0,0 +1,10 @@ +Contributed By: Mohammad Faisal Siddiqi +Course: btech +College/Institute/Organization: Jamia Milia Islamia, Delhi +Department/Designation: Electronics & CommunicationsEngg +Book Title: Electronic Communication Systems +Author: George Kennedy, Bernard Davis & A. R. M. Prasanna +Publisher: Tata Mcgraw Hill Education Private Limited +Year of publication: 2012 +Isbn: 978007107782-8 +Edition: 5th
\ No newline at end of file diff --git a/Electronic_Communication_Systems/screenshots/capacityTele.png b/Electronic_Communication_Systems/screenshots/capacityTele.png Binary files differnew file mode 100755 index 00000000..ecc089b5 --- /dev/null +++ b/Electronic_Communication_Systems/screenshots/capacityTele.png diff --git a/Electronic_Communication_Systems/screenshots/cuttoff.png b/Electronic_Communication_Systems/screenshots/cuttoff.png Binary files differnew file mode 100755 index 00000000..29247db2 --- /dev/null +++ b/Electronic_Communication_Systems/screenshots/cuttoff.png diff --git a/Electronic_Communication_Systems/screenshots/maxModulation.png b/Electronic_Communication_Systems/screenshots/maxModulation.png Binary files differnew file mode 100755 index 00000000..9e113893 --- /dev/null +++ b/Electronic_Communication_Systems/screenshots/maxModulation.png |
