From 206d0358703aa05d5d7315900fe1d054c2817ddc Mon Sep 17 00:00:00 2001 From: Jovina Dsouza Date: Wed, 18 Jun 2014 12:43:07 +0530 Subject: adding book --- Satellite_Communication/README.txt | 10 + Satellite_Communication/chapter_2.ipynb | 838 ++++++++++++++++++++++++++++++ Satellite_Communication/chapter_3.ipynb | 761 +++++++++++++++++++++++++++ Satellite_Communication/chapter_4.ipynb | 642 +++++++++++++++++++++++ Satellite_Communication/chapter_5.ipynb | 618 ++++++++++++++++++++++ Satellite_Communication/chapter_6.ipynb | 359 +++++++++++++ Satellite_Communication/chapter_7.ipynb | 761 +++++++++++++++++++++++++++ Satellite_Communication/screenshots/a.png | Bin 0 -> 170436 bytes Satellite_Communication/screenshots/b.png | Bin 0 -> 241075 bytes Satellite_Communication/screenshots/c.png | Bin 0 -> 220776 bytes 10 files changed, 3989 insertions(+) create mode 100644 Satellite_Communication/README.txt create mode 100644 Satellite_Communication/chapter_2.ipynb create mode 100644 Satellite_Communication/chapter_3.ipynb create mode 100644 Satellite_Communication/chapter_4.ipynb create mode 100644 Satellite_Communication/chapter_5.ipynb create mode 100644 Satellite_Communication/chapter_6.ipynb create mode 100644 Satellite_Communication/chapter_7.ipynb create mode 100644 Satellite_Communication/screenshots/a.png create mode 100644 Satellite_Communication/screenshots/b.png create mode 100644 Satellite_Communication/screenshots/c.png (limited to 'Satellite_Communication') diff --git a/Satellite_Communication/README.txt b/Satellite_Communication/README.txt new file mode 100644 index 00000000..4ec19377 --- /dev/null +++ b/Satellite_Communication/README.txt @@ -0,0 +1,10 @@ +Contributed By: Laxman Sole +Course: btech +College/Institute/Organization: Vishwakarma Institute of Technology,Pune +Department/Designation: Electronics +Book Title: Satellite Communication +Author: Anil K.maini Varsha Agrawal +Publisher: Wiley India Pvt. Ltd. New Delhi +Year of publication: 2010 +Isbn: 978-81-265-2071-8 +Edition: 1 \ No newline at end of file diff --git a/Satellite_Communication/chapter_2.ipynb b/Satellite_Communication/chapter_2.ipynb new file mode 100644 index 00000000..233fcb29 --- /dev/null +++ b/Satellite_Communication/chapter_2.ipynb @@ -0,0 +1,838 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "chapter 2: Satellite Orbits and Trajectories" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.1, page no-36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''satellite velocity'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "r1=6370.0 # Earth's Orbit in km\n", + "r2=630.0 # Height of satellite from surface in km\n", + "G=6.67*10**-11 # Gravitational constant inNm^2/kg^2\n", + "M=5.98*10**24 # Mass of earth in kg\n", + "\n", + "#Calculation\n", + "R=r1+r2\n", + "v=math.sqrt(G*M/(R*10**3))\n", + "\n", + "#Result\n", + "print(\"The velocity of sattelite %.2fkm/s\"%(math.floor(v/10)*10**-2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The velocity of sattelite 7.54km/s\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.2, page no-37" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''orbit parameters'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "A=45000.0 #Apogee in km\n", + "P=7000.0 #Perigee in km\n", + "\n", + "\n", + "#Calculation\n", + "#(a)\n", + "a=(A+P)/2\n", + "#(b)\n", + "e=(A-P)/(2*a)\n", + "#(c)\n", + "e=(math.floor(e*100))/100\n", + "d=a*e\n", + "\n", + "#Result\n", + "print(\"(a)\\nSemi-major axis of elliptical orbit is %d km\"%a)\n", + "print(\"\\n(b)\\nEccentricity = %.2f\"%e)\n", + "print(\"\\n(c)\\nThe distance between centre of earth and centre of ellipse is %d km \"%d)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + "Semi-major axis of elliptical orbit is 26000 km\n", + "\n", + "(b)\n", + "Eccentricity = 0.73\n", + "\n", + "(c)\n", + "The distance between centre of earth and centre of ellipse is 18980 km \n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.3, page no-37" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbit parameters'''\n", + "#Variable Declaration\n", + "ma=42000.0 # Major axis distance in Km\n", + "P=8000.0 # Perigee distance in Km\n", + "\n", + "\n", + "#Calculation\n", + "A=ma-P\n", + "e=(A-P)/ma\n", + "\n", + "#Result\n", + "print(\"Apogee=%dkm\\n Eccentricity=%.2f\"%(A,e))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Apogee=34000km\n", + " Eccentricity=0.62\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.4, page no-37" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbit parameters'''\n", + "\n", + "#Variable Declaration\n", + "e=0.6 #Eccentricity\n", + "d=18000.0 #distance between earth's centre and centre of ellipse\n", + "\n", + "\n", + "#Calculation\n", + "a=d/e\n", + "A=a*(1+e)\n", + "P=a*(1-e)\n", + "\n", + "\n", + "#Result\n", + "print(\"Semi-major axis of elliptical orbit is %d km\\n Apogee distance=%dkm\\n Perigee distance=%dkm\"%(a,A,P))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Semi-major axis of elliptical orbit is 30000 km\n", + " Apogee distance=48000km\n", + " Perigee distance=12000km\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.5, page no-38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbit Eccentricity'''\n", + "#Variable Declaration\n", + "AP_diff=30000.0 #difference between apogee and perigee in km\n", + "AP_sum=62800.0 #Apogee+perigee\n", + "\n", + "\n", + "#Calculation\n", + "E=AP_diff/AP_sum\n", + "\n", + "\n", + "#Result\n", + "print(\"Orbit Eccentricity= %.3f\"%E)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Orbit Eccentricity= 0.478\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.6, page no-38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Velocity of satellite at particular point '''\n", + "import math\n", + "#Variable Declaration\n", + "R=7000.0*10**3 # sattelite orbit in m\n", + "mu=39.8*10**13 # constant G*M in Nm^2/kg\n", + "A=47000.0*10**3 # appogee distance in m\n", + "P=7000.0*10**3 # perigee distance in m\n", + "\n", + "\n", + "#Calculation\n", + "v=math.sqrt(mu/R)\n", + "a=(A+P)/2\n", + "v1=math.sqrt(mu*((2/R)-(1/a)))\n", + "\n", + "\n", + "#Result\n", + "print(\"Velocity of satellite A at point X is v=%.2fkm/s\\nVelocity of satellite B at point X is V=%.3fkm/s\"%(v/1000,v1/1000))\n", + "#value in book is different at 3rd decimal place." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity of satellite A at point X is v=7.54km/s\n", + "Velocity of satellite B at point X is V=9.949km/s\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.7, page no-39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Velocity of satellite at particular point '''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "R=42000.0*10**3 #sattelite orbit in m\n", + "mu=39.8*10**13 #constant G*M in Nm^2/kg\n", + "A=42000.0*10**3 #appogee distance in m\n", + "P=7000.0*10**3 #perigee distance in m\n", + "\n", + "#Calculation\n", + "v=math.sqrt(mu/R)\n", + "a=(A+P)/2\n", + "v1=math.sqrt(mu*((2/R)-(1/a)))\n", + "\n", + "#Result\n", + "print(\"Velocity of satellite A at point X is v=%.3fkm/s\\n Velocity of satellite B at point X is V=%.3fkm/s\"%(v/1000,v1/1000))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity of satellite A at point X is v=3.078km/s\n", + " Velocity of satellite B at point X is V=1.645km/s\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.8, page no-40" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Velocity of satellite at particular point '''\n", + "import math\n", + "#Variable Declaration\n", + "R=25000.0*10**3 #sattelite orbit in m\n", + "mu=39.8*10**13 #constant G*M in Nm^2/kg\n", + "A=43000.0*10**3 #appogee distance in m\n", + "P=7000.0*10**3 #perigee distance in m\n", + "\n", + "#Calculation\n", + "v=math.sqrt(mu/R)\n", + "a=(A+P)/2\n", + "v1=math.sqrt(mu*((2/R)-(1/a)))\n", + "\n", + "#Result\n", + "print(\"Velocity of satellite A at point X is v=%.3fkm/s\\n Velocity of satellite B at point X is V=%.3fkm/s\"%(v/1000,v1/1000))\n", + "#value in book is different at 3rd decimal place." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity of satellite A at point X is v=3.990km/s\n", + " Velocity of satellite B at point X is V=3.990km/s\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.9, page no-40" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbital time period'''\n", + "import math\n", + "#Variable Declaration\n", + "a=(50000.0/2)*10**3 #Semi-major axis in m\n", + "mu=39.8*10**13 #constant G*M in Nm^2/kg\n", + "\n", + "\n", + "#Calculation\n", + "T=2*math.pi*math.sqrt((a**3)/mu) #math.pi gives variation in answer\n", + "h=T/(60*60)\n", + "x=T%3600\n", + "m=x/60\n", + "s=x%60\n", + "\n", + "#Result\n", + "print(\"Orbital time period is given by, T = %dsec\\n\\t\\t\\t\\t = %dh %dm %ds\"%(T,math.floor(h),math.floor(m),math.floor(s)))\n", + "#value in book is different for seconds." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Orbital time period is given by, T = 39368sec\n", + "\t\t\t\t = 10h 56m 8s\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.10, page no-42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbital time period'''\n", + "#Variable Declaration\n", + "a1=18000.0*10**3 #Semi-major axis for first satellite in m\n", + "a2=24000.0*10**3 #Semi-major axis f0r 2nd satellite in m\n", + "\n", + "#Calculation\n", + "T2_by_T1=(a2/a1)**(3.0/2.0)\n", + "\n", + "#Result\n", + "print(\"Orbital time period of sattelite 2 is %.2f times that of sattelite 1\"%T2_by_T1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Orbital time period of sattelite 2 is 1.54 times that of sattelite 1\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.11, page no-42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbit parameters'''\n", + "import math\n", + "#Variable Declaration\n", + "a=25000.0*10**3 #appogee distance in m\n", + "b=18330.0*10**3 #perigee distance in m\n", + "\n", + "\n", + "#Calculation\n", + "e=(math.sqrt(a**2-b**2)/a)\n", + "\n", + "\n", + "#Result\n", + "print(\"Apogee distance = a(1+e)= %dkm\\n Perigee distance = a(1-e)= %dkm\\n\"%(a*(1+e)/1000,math.ceil(a*(1-e)/1000)))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Apogee distance = a(1+e)= 42000km\n", + " Perigee distance = a(1-e)= 8000km\n", + "\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.12, page no-43" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable Declaration\n", + "e=0.6 # eccentricity of elliptical orbit\n", + "a=0.97 # area of shaded region\n", + "b=2.17 # Area of non-shaded region\n", + "t=3 # time taken by satellite to move from pt B to A\n", + "\n", + "\n", + "#Calculation\n", + "x=b/a\n", + "y=x*t\n", + "\n", + "#Result\n", + "print(\"Time taken by satellite to move from A to B is %.3f hours \"%y)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time taken by satellite to move from A to B is 6.711 hours \n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.13, page no-44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Velocity at apogee'''\n", + "#Variable Declaration\n", + "A=42000.0 # Apogee in km\n", + "P=8000.0 # Perigee in km\n", + "v_p=9.142 # velocity at perigee point\n", + "\n", + "\n", + "#Calculation\n", + "v_a=v_p*P/A\n", + "\n", + "\n", + "#Result\n", + "print(\"Velocity at apogee = %.3f km/s\"%v_a)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity at apogee = 1.741 km/s\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.14, page no-44" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''velocity of satellite at particular point'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "theta=56.245 #angle made by direction of satellite with local horizontal\n", + "d=16000.0 #distance of particular point\n", + "P=8000.0 #Perigee in m\n", + "v_p=9.142 #velocity at perigee point\n", + "\n", + "\n", + "#Calculation\n", + "v=(P*v_p)/(d*math.floor(math.cos(theta*math.pi/180)*1000)/1000)\n", + "\n", + "\n", + "#Result\n", + "print(\"The velocity of satellite at that particular point is %.3f km/s\"%v)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The velocity of satellite at that particular point is 8.236 km/s\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.16, page no-49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''New apogee distance'''\n", + "import math\n", + "#Variable Declaration\n", + "A1=12000.0 # first Apogee distance\n", + "P=8000.0 # Perigee distance\n", + "v1=1.0 # assume v1 as 1\n", + "v2=1.2*v1 # 20% higher than v1 \n", + "\n", + "\n", + "#Calculation\n", + "x=(v2/v1)**2\n", + "k=(((1+(P/A1))/x)-1)\n", + "k=math.floor(k*10**4)/10**4\n", + "A2=P/k\n", + "\n", + "\n", + "#Result\n", + "print(\"A2 = %.0fkm\"%math.ceil(A2))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "A2 = 50826km\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.17, page no-50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''satellite velocity'''\n", + "import math\n", + "#Variable Declaration\n", + "vp=8.0 # horizontal velocity of satellite in km/s\n", + "r=1620.0 # distance from earth's surface in km\n", + "R=6380.0 # Earth's radius in km\n", + "d=10000.0 # distance of point at which velocity to be calculated\n", + "theta=30.0 # angle made by satellite with local horzon at that point\n", + "\n", + "\n", + "#Calculation\n", + "P=r+R\n", + "v=(vp*P)/(d*math.cos(theta*math.pi/180))\n", + "\n", + "#Result\n", + "print(\"v = %.2f km/s\"%v)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "v = 7.39 km/s\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.18, page no-50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Apogee distance'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "r=620.0 # distance from earth's surface in km\n", + "vp=8.0 # horizontal velocity of satelliteat 9000km height in km/s\n", + "R=6380.0 # Earth's radius in km\n", + "d=9000.0 # distance of point at which velocity to be calculated\n", + "theta=30.0 # angle made by satellite with local horzon at that point\n", + "mu=39.8*10**13 # Nm**2/kg\n", + "\n", + "\n", + "#Calculation\n", + "P=r+R\n", + "m=vp*d*math.cos(theta*math.pi/180)/P #m=sqrt((2mu/P)-[2mu/(A+P)])\n", + "m=(m*10**3)**2\n", + "x=(2*mu/(P*10**3))-m #x=[2mu/(A+P)]\n", + "x=math.floor(x/10**4)*10**4\n", + "k=(2*mu)/x #k=A+P\n", + "k=math.ceil(k/10**4)*10**4\n", + "A=k-(P*10**3)\n", + "\n", + "#Result\n", + "print(\"A = %.0f km\"%(A/1000))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "A = 16170 km\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.19, page no-58" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Height of satellite orbit above eart surface'''\n", + "\n", + "import math\n", + "#variable declaration\n", + "R=6380 #Earth's radius in km\n", + "T=86160 #Orbital period of Geostationary satellite in km\n", + "mu=39.8*10**13 #in Nm^2/k\n", + "\n", + "#calculations\n", + "\n", + "r=(T*math.sqrt(mu)/(2*math.pi))**(2.0/3.0) # Answer matches to the answer given in the book if value of pi is taken as 3.14 \n", + "\n", + "#Result\n", + "print('Radius of satellite is, r = %.0f km'%(r/1000))\n", + "print('Therefore, height of satellite orbit above earth surface is %.0f km '%((r/1000)-R))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Radius of satellite is, r = 42142 km\n", + "Therefore, height of satellite orbit above earth surface is 35762 km \n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 2.20, page no-59" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Orbital time period'''\n", + "import math\n", + "#variable declaration\n", + "\n", + "R=6380 #radius of earth in km\n", + "P=400 #Perigee distance in km\n", + "A=40000 #Apogee distance in km\n", + "mu=39.8*10**13 #in Nm^2/k\n", + "\n", + "#calculation\n", + "\n", + "a=(A+P+R+R)/2 #semi-major axis of the elliptical orbit\n", + "\n", + "T=(2*math.pi*(a*10**3)**(3.0/2.0))/math.sqrt(mu)\n", + "\n", + "h=T/(60*60)\n", + "x=T%3600\n", + "m=x/60\n", + "s=x%60\n", + "\n", + "#Result\n", + "print('T = %dsec\\n = %dh %dm %ds\\n\\nThis approximately equal to 12 hour'%(T,math.floor(h),math.floor(m),math.floor(s)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "T = 43158sec\n", + " = 11h 59m 18s\n", + "\n", + "This approximately equal to 12 hour\n" + ] + } + ], + "prompt_number": 34 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/chapter_3.ipynb b/Satellite_Communication/chapter_3.ipynb new file mode 100644 index 00000000..376a12af --- /dev/null +++ b/Satellite_Communication/chapter_3.ipynb @@ -0,0 +1,761 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3: Satellite Launch and In-Orbit Operations" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.1, page no-72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Inclination angle'''\n", + "import math\n", + "#Variable Declaration\n", + "Az=85 # Azimuth angle of injection point\n", + "l=5.2 # latitude of launch site\n", + "\n", + "\n", + "#Calculation\n", + "cosi=math.sin(Az*math.pi/180)*math.cos(l*math.pi/180)\n", + "i=math.acos(cosi)\n", + "i=i*180.0/math.pi\n", + "\n", + "\n", + "#Result\n", + "print(\"Inclination angle attained, i=%.1f\u00b0\"%i)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inclination angle attained, i=7.2\u00b0\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.2, page no-73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Velocity thrust'''\n", + "import math\n", + "#Variable Declaration\n", + "delta_i=7 #orbital plane inclination\n", + "V=3000 #velocity of satellite in circularized orbit\n", + "\n", + "\n", + "#Calculation\n", + "vp=2*V*math.sin(delta_i*math.pi/(2*180))\n", + "\n", + "\n", + "#Result\n", + "print(\"Velocity thrust to make the inclination 0\u00b0 = %.0f m/s\"%vp)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Velocity thrust to make the inclination 0\u00b0 = 366 m/s\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.3, page no-73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''velocity thrust'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "mu=39.8*10**13 # Nm^2/kg\n", + "P=7000.0*10**3 # Perigee distance in m\n", + "e=0.69 # eccentricity of eliptical orbit\n", + "w=60.0/2 # angle made by line joing centre of earth and perigee with the line of nodes\n", + "\n", + "\n", + "#Calculation\n", + "k=(e/math.sqrt(1+e))\n", + "k=math.floor(k*100)/100\n", + "v=2*(math.sqrt(mu/P))*k*math.sin(w*math.pi/180.0)\n", + "\n", + "\n", + "#Result\n", + "print(\"The velocity thrust required to rotate the perigee point\\n by desired amount is given by, v=%.1f m/s = %.3fkm/s\"%(v,v/1000.0))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The velocity thrust required to rotate the perigee point\n", + " by desired amount is given by, v=3996.4 m/s = 3.996km/s\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.4, page no-74" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Thrust velocity'''\n", + "import math\n", + "#Variable Declaration\n", + "A=15000*10**3 #Original apogee distance\n", + "A1=25000*10**3 # Raised opogee distance\n", + "P=7000*10**3 # Perigee Distance\n", + "mu=39.8*10**13 #Nm**2/kg\n", + "\n", + "\n", + "#Calculation\n", + "A_d=A1-A\n", + "v=math.sqrt((2*mu/P)-(2*mu/(A+P)))\n", + "del_v=A_d*mu/(v*(A+P)**2)\n", + "\n", + "\n", + "#Result\n", + "print(\"required Thrust velocity Delta_v = %.1f m/s\"%del_v)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "required Thrust velocity Delta_v = 933.9 m/s\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.5, page no-75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Thrust velocity'''\n", + "import math\n", + "#Variable Declaration\n", + "A=15000.0*10**3 # Original apogee distance\n", + "A1=7000.0*10**3 # Raised opogee distance\n", + "P=7000.0*10**3 # Perigee Distance\n", + "mu=39.8*10**13 # Nm^2/kg\n", + "\n", + "\n", + "#Calculation\n", + "A_d=A-A1\n", + "v=math.sqrt((2*mu/P)-(2*mu/(A+P)))\n", + "del_v=A_d*mu/(v*(A+P)**2)\n", + "\n", + "#Result\n", + "print(\"required Thrust velocity Delta_v = %.1f m/s\"%del_v)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "required Thrust velocity Delta_v = 747.1 m/s\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.6, page no-76" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Thrust velocity '''\n", + "#Variable Declaration\n", + "A=15000.0*10**3 # Original apogee distance\n", + "A1=16000.0*10**3 # Raised opogee distance\n", + "P=7000.0*10**3 # Perigee Distance\n", + "mu=39.8*10**13 # Nm**2/kg\n", + "\n", + "\n", + "#Calculation\n", + "A_d=A1-A\n", + "v=math.sqrt((2*mu/P)-(2*mu/(A+P)))\n", + "v=v*P/A\n", + "del_v=A_d*mu/(v*(A+P)**2)\n", + "\n", + "#Result\n", + "print(\"required Thrust velocity Delta_v = %.1f m/s\"%del_v)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "required Thrust velocity Delta_v = 200.1 m/s\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.7, page no-77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Thrust velocity'''\n", + "import math\n", + "#Variable Declaration\n", + "R=6378.0*10**3 # Radius of earth\n", + "mu=39.8*10**13 # Nm**2/kg\n", + "r1=500.0*10**3 # original orbit from earths surface\n", + "r2=800.0*10**3 # orbit to be raised to thisdistance\n", + "\n", + "\n", + "#Calculation\n", + "R1=R+r1\n", + "R2=R+r2\n", + "delta_v=math.sqrt(2*mu*R2/(R1*(R1+R2)))-math.sqrt(mu/R1)\n", + "delta_v_dash=math.sqrt(mu/R2)-math.sqrt(2*mu*R1/(R2*(R1+R2)))\n", + "\n", + "\n", + "#Result\n", + "print(\"Two thrusts to be applied are,\\n Delta_v = %.2f m/s \\n Delta_v_dash = %.2f m/s\"%(delta_v,delta_v_dash))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Two thrusts to be applied are,\n", + " Delta_v = 80.75 m/s \n", + " Delta_v_dash = 79.89 m/s\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.8, page no-97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Maximum line-of-sight distance'''\n", + "import math\n", + "#Variable Declaration\n", + "H=36000.0 # Height of geostationary satellite from the surface of earth\n", + "R=6370.0 # Radius of earth in km\n", + "\n", + "\n", + "#Calculation\n", + "k=math.acos(R/(R+H))\n", + "#k=k*180/%pi\n", + "k=math.sin(k)\n", + "k=math.ceil(k*1000)/1000\n", + "d=2*(H+R)*k\n", + "\n", + "\n", + "#Result\n", + "print(\"Maximum line-of-sight distance is %.2f km\"%d)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum line-of-sight distance is 83807.86 km\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.9, page no-98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "''' line-of-sight distance'''\n", + "import math\n", + "#Variable Declaration\n", + "H=36000.0 # Height of geostationary satellite from the surface of earth\n", + "R=6370.0 # Radius of earth in km\n", + "theta=20.0 # angular separation between two satellites\n", + "\n", + "\n", + "#Calculation\n", + "D=(H+R)\n", + "k=math.ceil(math.cos(theta*math.pi/180.0)*100)/100\n", + "d=math.sqrt(2*D**2*(1-k))\n", + "\n", + "\n", + "#Result\n", + "print(\"The line-of-sight distance is %.4f km\"%d)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The line-of-sight distance is 14677.3985 km\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.10, page no-98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Inter-satellite distance'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "\n", + "#IntelSat-VI location= 37 W\n", + "# IntelSat-VII location=74 E\n", + "theta=37+74 # angular separation between two satellites\n", + "D=42164.0 # circular equilateral geostationary orbit in km\n", + "\n", + "\n", + "#Calculation\n", + "k=math.cos(math.pi*theta/180.0)\n", + "#printf(\"%f\\n\",k)\n", + "k=-0.357952\n", + "d=math.sqrt(2*D**2*(1-k))\n", + "\n", + "\n", + "#Result\n", + "print(\"Inter-satellite distance is %.2f km\"%d)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inter-satellite distance is 69486.27 km\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.11, page no-99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Azimuth and elevation angle'''\n", + "import math\n", + "\n", + "theta_l=30.0 # earth station's location 30\u00b0W longitude\n", + "theta_s=50.0 # satellite's location 50\u00b0W longitude\n", + "theta_L=60.0 # earth station's location 60\u00b0N latitude\n", + "r=42164.0 # orbital radius of the satellite in km\n", + "R=6378.0 # Earth's radius in km\n", + "\n", + "A_dash=math.atan((math.tan(math.pi*(theta_s-theta_l)/180.0))/math.sin(math.pi*60/180.0))\n", + "A_dash=A_dash*180/math.pi\n", + "A=180+A_dash #Azimuth angle\n", + "\n", + "x=(180/math.pi)*math.acos(math.cos(math.pi*(theta_s-theta_l)/180.0)*math.cos(math.pi*theta_L/180))\n", + "y=r-math.ceil(R*(math.cos(math.pi*(theta_s-theta_l)/180.0)*math.cos(math.pi*theta_L/180)))\n", + "z=R*math.sin(math.pi*x/180)\n", + "E=(math.atan(y/z)*180/math.pi)-x\n", + "print(\"Azimuth angle =%.1f\u00b0\\n Elevation angle =%.1f\u00b0\"%(A,E))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Azimuth angle =202.8\u00b0\n", + " Elevation angle =19.8\u00b0\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.12, page no-100" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Time Delay'''\n", + "import math\n", + "#Variable Declaration\n", + "theta_l=60.0 #earth station's location 60\u00b0W longitude\n", + "theta_s=105.0 #satellite's location 105\u00b0W longitude\n", + "theta_L=30.0 #earth station's location 30\u00b0N latitude\n", + "\n", + "theta_l1=90.0 #earth station's location 90\u00b0W longitude\n", + "theta_s1=105.0 #satellite's location 105\u00b0W longitude\n", + "theta_L1=45.0 #earth station's location 45\u00b0N latitude\n", + "\n", + "c=3*10**8 # speed of light\n", + "r=42164.0 # orbital radius of the satellite in km\n", + "R=6378.0 # Earth's radius in km\n", + "\n", + "\n", + "#Calculation\n", + "\n", + "x=(180/math.pi)*math.acos(math.cos(math.pi*(theta_s-theta_l)/180)*math.cos(math.pi*theta_L/180))\n", + "y=r-math.ceil(R*(math.cos(math.pi*(theta_s-theta_l)/180)*math.cos(math.pi*theta_L/180)))\n", + "z=R*math.sin(math.pi*x/180)\n", + "E=(math.atan(y/z)*180/math.pi)-x\n", + "\n", + "x1=(180/math.pi)*math.acos(math.cos(math.pi*(theta_s1-theta_l1)/180)*math.cos(math.pi*theta_L1/180))\n", + "y1=r-math.ceil(R*(math.cos(math.pi*(theta_s1-theta_l1)/180)*math.cos(math.pi*theta_L1/180)))\n", + "z1=R*math.sin(math.pi*x1/180)\n", + "E1=(math.atan(y1/z1)*180/math.pi)-x1\n", + "E1=math.floor(E1)\n", + "\n", + "#calculation of slant range dx\n", + "k=(R/r)*math.cos(math.pi*E/180)\n", + "k=(180/math.pi)*math.asin(k)\n", + "k=k+E\n", + "k=math.sin(math.pi*k/180)\n", + "k=math.ceil(k*1000)/1000\n", + "#k=k+E\n", + "#k=sin(k)\n", + "dx=(R)**2+(r)**2-(2*r*R*k)\n", + "dx=math.sqrt(dx)\n", + "\n", + "\n", + "#calculation of slant range dy\n", + "k1=(R/r)*math.cos(math.pi*E1/180)\n", + "k1=(180/math.pi)*math.asin(k1)\n", + "k1=k1+E1\n", + "k1=math.floor(k1)\n", + "k1=math.sin(math.pi*k1/180)\n", + "k1=math.ceil(k1*1000)/1000\n", + "dy=(R)**2+(r)**2-(2*r*R*k1)\n", + "dy=math.sqrt(dy)\n", + "\n", + "tr=dy+dx\n", + "delay=tr*10**6/c\n", + "x=50\n", + "td=delay+x\n", + "\n", + "\n", + "#Result\n", + "print(\"Elevation angle, Ex =%.1f\u00b0\"%E)\n", + "print(\"\\n Elevation angle, Ey =%.1f\u00b0\"%math.floor(E1))\n", + "print(\"\\n Slant range dx of the earth station X is dx=%.2fkm\"%dx)\n", + "print(\"\\n Slant range dy of the earth station Y is dy=%.1fkm\"%dy)\n", + "print(\"\\n Therefore, total range to be covered is %.2fkm\"%tr)\n", + "print(\"\\n propagation delay=%.2fms\"%delay)\n", + "print(\"\\n\\n Time required too transmit 500 kbs of information at \\n a transmisssion speed of 10Mbps is given by 500000/10^7=%.0fms\"%(500000000.0/10**7))\n", + "print(\"\\n\\n Total Delay= %.2fms\"%td)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Elevation angle, Ex =30.3\u00b0\n", + "\n", + " Elevation angle, Ey =36.0\u00b0\n", + "\n", + " Slant range dx of the earth station X is dx=38584.76km\n", + "\n", + " Slant range dy of the earth station Y is dy=38100.8km\n", + "\n", + " Therefore, total range to be covered is 76685.57km\n", + "\n", + " propagation delay=255.62ms\n", + "\n", + "\n", + " Time required too transmit 500 kbs of information at \n", + " a transmisssion speed of 10Mbps is given by 500000/10^7=50ms\n", + "\n", + "\n", + " Total Delay= 305.62ms\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.13, page no-102" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Inter-satellite distance'''\n", + "import math\n", + "#Variable Declaration\n", + "da=38000.0 # slant range of satellite A\n", + "db=36000.0 # slant range of satellite B\n", + "beeta=60.0 # difference between longitudes of two satellites\n", + "R=42164.0 # radius of the orbit of satellites\n", + "\n", + "\n", + "#Calculation\n", + "theta=(da**2+db**2-2*(R**2)*(1-math.cos(math.pi*beeta/180)))/(2*da*db)\n", + "theta=(180/math.pi)*math.acos(theta)\n", + "d=math.sqrt(2*(R**2)*(1-math.cos(math.pi*beeta/180)))\n", + "\n", + "\n", + "#Result\n", + "print(\"Angular spacing between two satellites viewed by earth station is,\\n theta= %.1f\u00b0\"%theta)\n", + "print(\"\\nInter-satellite distance , d=%.0fkm\"%d)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Angular spacing between two satellites viewed by earth station is,\n", + " theta= 69.4\u00b0\n", + "\n", + "Inter-satellite distance , d=42164km\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.14, page no-107" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''covered surface area'''\n", + "import math\n", + "#Variable Declaration\n", + "r=42164.0 # orbital radius of the satellite in km\n", + "R=6378.0 # Earth's radius in km\n", + "\n", + "#refer to Figure 3.53\n", + "\n", + "#Calculation\n", + "\n", + "#for E=0\u00b0\n", + "alfa=math.asin(R/r)*(180/math.pi)\n", + "alfa=math.floor(alfa*10)/10\n", + "theta=90-alfa\n", + "#in the right angle triangle OAC,\n", + "k=math.sin(math.pi*alfa/180)\n", + "k=math.floor(k*1000)/1000\n", + "oc=R*k\n", + "oc=math.ceil(oc*10)/10\n", + "A=2*math.pi*R*(R-oc)\n", + "\n", + "\n", + "#for E=10\u00b0\n", + "E=10\n", + "alfa1=math.asin((R/r)*math.cos(math.pi*E/180))*(180/math.pi)\n", + "#alfa1=ceil(alfa1*100)/100\n", + "theta1=90-alfa1-E\n", + "#in the right angle triangle OAC,\n", + "k1=math.sin(math.pi*(alfa1+E)/180)\n", + "k1=math.floor(k1*1000)/1000\n", + "oc1=R*k1\n", + "oc1=math.floor(oc1*10)/10\n", + "A1=2*math.pi*R*(R-oc1)\n", + "\n", + "\n", + "#Result\n", + "print(\"for E=0\u00b0,\\n covered surface area is %.1f km^2\"%A)\n", + "print(\"\\n\\n for E=10\u00b0,\\n covered surface area is %.1f km^2\"%A1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "for E=0\u00b0,\n", + " covered surface area is 216997546.7 km^2\n", + "\n", + "\n", + " for E=10\u00b0,\n", + " covered surface area is 174314563.3 km^2\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 3.15, page no-108" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Area swept by ground track of sattelite'''\n", + "#variable declaration\n", + "theta=30 #satellite inclination to the equitorial plan\n", + "#the extreme latitudes covered in northern and southern hemisphere are the same as orbit inclination\n", + "\n", + "print(\"Extreme Northern latitude covered = %.0f\u00b0 N\"%theta)\n", + "print(\"\\n Extreme Southern latitude covered = %.0f\u00b0 S\"%theta)\n", + "print(\"\\n\\n In fact, the ground track would sweep\\n all latitudes between %d\u00b0N and %d\u00b0S\"%(theta,theta))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Extreme Northern latitude covered = 30\u00b0 N\n", + "\n", + " Extreme Southern latitude covered = 30\u00b0 S\n", + "\n", + "\n", + " In fact, the ground track would sweep\n", + " all latitudes between 30\u00b0N and 30\u00b0S\n" + ] + } + ], + "prompt_number": 16 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/chapter_4.ipynb b/Satellite_Communication/chapter_4.ipynb new file mode 100644 index 00000000..85428bc4 --- /dev/null +++ b/Satellite_Communication/chapter_4.ipynb @@ -0,0 +1,642 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4: Satellite Hardware" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.1, page no-122" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Ejection velocity of the propellant mass'''\n", + "\n", + "#Variable Declaration\n", + "I=250 #specific impulse of a propellant\n", + "g=9.807 # acceleration due to gravity\n", + "\n", + "\n", + "#Calculation\n", + "v=I*g\n", + "\n", + "\n", + "#Result\n", + "print(\"Ejection velocity of the propellant mass is, v= %.2f m/s\"%v)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Ejection velocity of the propellant mass is, v= 2451.75 m/s\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.2, page no-122" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Mass of propellant'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "m=4330.0 #initial mass of the satellite\n", + "i=290.0 #specific impulse of a propellant\n", + "del_v=-100 #velocity increment\n", + "g=9.807 #acceleration due to gravity\n", + "\n", + "\n", + "#Calculation\n", + "m1=m*(1-math.exp(del_v/(g*i)))\n", + "\n", + "\n", + "#Result\n", + "print(\"Mass of propellant necessary to be burnt is, m= %.0fkg\"%math.ceil(m1))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Mass of propellant necessary to be burnt is, m= 150kg\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.3, page no-123" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Mass of propellant'''\n", + "#Variable Declaration\n", + "m=2950.0 #initial mass of the satellite\n", + "F=450.0 #required thrust\n", + "T=10.0 #thrust for time period\n", + "i=300.0 #specific impulse of a propellant\n", + "g=9.807 #acceleration due to gravity\n", + "\n", + "\n", + "#Calculation\n", + "mi=F*T/(i*g)\n", + "\n", + "\n", + "#Result\n", + "print(\"Mass of propellant that would be consumed is, m=%.2fkg\"%mi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Mass of propellant that would be consumed is, m=1.53kg\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.5, page no-134" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''solar cells'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "p=2000.0 # electrical energy to be generated from solar panel in Watt\n", + "fi=1250.0 # solar flux falling normally to the solar cell in worst case\n", + "s=4*10**-4 # Area of each solar cell\n", + "e=0.15 # conversion efficiency of solar cell includingthe losses\n", + "theta=10.0 # angle made by rays of sun with normal \n", + "\n", + "\n", + "#Calculation\n", + "n=p/(fi*s*e)\n", + "n1=math.ceil(n)*math.pi\n", + "n2=math.ceil(n1)/math.cos(math.pi*(theta)/180.0)\n", + "\n", + "\n", + "#Result\n", + "print(\"Required no of solar cells, n = %.0f cells\"%math.ceil(n1))\n", + "print(\"\\n No of cells when sunrays are making an angle of 10\u00b0 are %.0f\"%math.ceil(n2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Required no of solar cells, n = 83777 cells\n", + "\n", + " No of cells when sunrays are making an angle of 10\u00b0 are 85070\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.6, page no-134" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Battery System Requirement'''\n", + "#Variable Declaration\n", + "p=3600.0 #Power required\n", + "t=1.2 #worst case eclipse period\n", + "c=90.0 #capacity of each cell in Ah\n", + "v=1.3 #voltage of each cell in V\n", + "d=0.8 # Depth of discharge\n", + "e=0.95 #Discharge efficiency\n", + "E_sp=60.0 #specific energy specification of the battery\n", + "\n", + "\n", + "#Calculation\n", + "energy=p*t\n", + "n=energy/(c*v*d*e)\n", + "E_b=energy/(d*e)\n", + "m=E_b/E_sp\n", + "\n", + "\n", + "#Result\n", + "print(\"No of cells, n= %.0f cells\\n Energy required to be stored in the battery system is %.1f Wh\\n Mass of battery system = %.2f kg\"%(n,E_b,m))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No of cells, n= 49 cells\n", + " Energy required to be stored in the battery system is 5684.2 Wh\n", + " Mass of battery system = 94.74 kg\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.7, page no-153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Antenna Gain'''\n", + "import math\n", + "#Variable Declaration\n", + "theta=0.5 #azimuth beam width=Elevation beam width\n", + "f=6.0*10**9 #operating frequency 6 Ghz\n", + "c=3.0*10**8 #speed of light in cm/s\n", + "\n", + "\n", + "#Calculation\n", + "theta_r=theta*math.pi/180.0\n", + "theta_r=math.ceil(theta_r*10**5)/10**5\n", + "A=4*math.pi/(theta_r**2)\n", + "A=math.ceil(A*100)/100\n", + "A_dB=10*math.log10(A)\n", + "lam=c/f\n", + "Ag=(A*lam**2)/(4*math.pi)\n", + "\n", + "\n", + "#Result\n", + "print(\"Gain in dB = %.2f dB \\nAntenna gain expressed in terms of\\nantenna aperture(A) is given by G = %.2f m^2\"%(A_dB,Ag))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Gain in dB = 52.17 dB \n", + "Antenna gain expressed in terms of\n", + "antenna aperture(A) is given by G = 32.80 m^2\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.8, page no-153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Aperture efficiency and Effective Aperture'''\n", + "#Variable Declaration\n", + "la=0.5 #length efficiency in azimuth direction\n", + "le=0.7 #length efficiency in elevation direction \n", + "A=10 #Actual projected area of an antenna\n", + "\n", + "\n", + "#Calculation\n", + "Ae=la*le\n", + "Aee=Ae*A\n", + "\n", + "#Result\n", + "print(\"Aperture efficiency = %.2f \\n Effective Aperture = %.1f m^2\"%(Ae,Aee))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Aperture efficiency = 0.35 \n", + " Effective Aperture = 3.5 m^2\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.9, page no-154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Directivity'''\n", + "import math\n", + "#Variable Declaration\n", + "p=100 #Antenna power in W\n", + "pd=10 #Power Density in mW/m^2\n", + "d=1000 #distance in m\n", + "p2=10000 #New antenna power\n", + "\n", + "\n", + "#Calculation\n", + "directivity=10*math.log10(p2/p)\n", + "\n", + "\n", + "#Result\n", + "print(\"Directivity (in dB)= %d dB\"%directivity)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Directivity (in dB)= 20 dB\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.10, page no-154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''null-to-null beam width'''\n", + "#Variable Declaration\n", + "beam_w=0.4 #antenna's 3dB beam width\n", + "Ae=5 #Effective Aperture of Antenna\n", + "\n", + "\n", + "#Result\n", + "print(\"The null-to-null beam width of a paraboloid reflector is twice its 3dB beam width. \\n Therefore, Null-to-null beam width = %.1f\u00b0\"%(2*beam_w))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The null-to-null beam width of a paraboloid reflector is twice its 3dB beam width. \n", + " Therefore, Null-to-null beam width = 0.8\u00b0\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.11, page no-154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Polarization loss and Received signal strength'''\n", + "import math\n", + "#Variable Declaration\n", + "d=20.0 #received signal strenth in dB\n", + "loss=3.0 #incident polarization is circular and antenna is circularly polarized\n", + "theta=60.0 #received wave making angle with horizontal\n", + "\n", + "\n", + "#Calculation\n", + "total=d+loss\n", + "los=d*math.log10(1/math.cos(math.pi*theta/180.0))\n", + "\n", + "\n", + "#Result\n", + "print(\"(a)\\n When received polarization is same as antenna \\n polarization,thepolarization loss is zero.\\n Therefore, received sinal strenth = %ddB\"%total)\n", + "print(\"\\n\\n(b)\\n When the incident wave is vertically polarized,\\n the angle between incident polarization and antenna polarization is 90\u00b0\\n Hence, Polarization loss = infinity\\n received signal strength = 0\")\n", + "print(\"\\n\\n(c)\\n When incident wave is left-hand circularly polarized\\n and antenna polarization is linear,\\n then there is polarization loss of %ddB and\\n received signal strength is %ddB\"%(loss,d))\n", + "print(\"\\n\\n(d)\\n Polarization loss = %ddB \\n Received signal strength = %ddB\"%(los,math.ceil(total-los)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + " When received polarization is same as antenna \n", + " polarization,thepolarization loss is zero.\n", + " Therefore, received sinal strenth = 23dB\n", + "\n", + "\n", + "(b)\n", + " When the incident wave is vertically polarized,\n", + " the angle between incident polarization and antenna polarization is 90\u00b0\n", + " Hence, Polarization loss = infinity\n", + " received signal strength = 0\n", + "\n", + "\n", + "(c)\n", + " When incident wave is left-hand circularly polarized\n", + " and antenna polarization is linear,\n", + " then there is polarization loss of 3dB and\n", + " received signal strength is 20dB\n", + "\n", + "\n", + "(d)\n", + " Polarization loss = 6dB \n", + " Received signal strength = 17dB\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.12, page no-155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Antenna Gain and beam width'''\n", + "import math\n", + "#Variable Declaration\n", + "Ea=1 #effective aperture\n", + "f=11.95*10**9 #downlink operating frequency\n", + "c=3*10**8 #speed of light\n", + "\n", + "Ae=math.floor((math.pi*1000*Ea**2)/4)/1000\n", + "lamda=math.floor(c*1000/f)/1000\n", + "ag=math.floor(100*4*math.pi*Ae/lamda**2)/100\n", + "adb=math.floor(100*10*math.log10(ag))/100\n", + "width=70*lamda/Ea\n", + "print(\"Operating wavelength = %.3fm\\n Antenna Gain = %.2f\\n Antenna Gain in dB = %.2fdB\\n 3dB beam width = %.2f\u00b0\"%(lamda,ag,adb,width))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Operating wavelength = 0.025m\n", + " Antenna Gain = 15783.36\n", + " Antenna Gain in dB = 41.98dB\n", + " 3dB beam width = 1.75\u00b0\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.13, page no-155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Beam Width'''\n", + "import math\n", + "#Variable Declaration\n", + "f=2.0 # reflector focal length\n", + "d=2.0 # reflector diameter\n", + "l=90.0/100.0 # 90% of the angle\n", + "\n", + "\n", + "#Calculation\n", + "theta=4*180.0*(math.atan(1/(4*f/d)))/math.pi\n", + "theta=4*180.0*math.atan(0.25007)/math.pi # this value gives exact answer as in book\n", + "dbw=l*theta\n", + "\n", + "#Result\n", + "print(\"The angle subtended by the focal point feed\\n at the edges of the reflector is, theeta = %.2f\u00b0\\n\\n 3dB beam width = %.2f\u00b0\\n null-to-null beam width = % .2f\u00b0\"%(theta,dbw,math.floor(200.0*dbw)/100.0))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The angle subtended by the focal point feed\n", + " at the edges of the reflector is, theeta = 56.16\u00b0\n", + "\n", + " 3dB beam width = 50.54\u00b0\n", + " null-to-null beam width = 101.08\u00b0\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.14, page no-155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''phase angles'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "c=3*10**8 #speed of light \n", + "f=2.5*10**9 #operating frequency\n", + "s=0.1 #inter element spacing\n", + "theta =10 #10\u00b0 right towards array axis\n", + "\n", + "#Calculation\n", + "l=c/f\n", + "fi=(360*s/l)*math.ceil(10000*math.sin(math.pi*theta/180.0))/10000\n", + "fi=math.ceil(10*fi)/10\n", + "\n", + "#Result\n", + "print(\"The phase angle for elements 1,2,3,4 and 5 \\n are respecively 0\u00b0,%.1f\u00b0,%.1f\u00b0,%.1f\u00b0 and %.1f\u00b0\"%(fi,2*fi,3*fi,4*fi))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The phase angle for elements 1,2,3,4 and 5 \n", + " are respecively 0\u00b0,52.2\u00b0,104.4\u00b0,156.6\u00b0 and 208.8\u00b0\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 4.15, page no-156" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Earth station EIRP'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "p=10000 #power fed to the antenna in W\n", + "ag=60 #Antenna gain\n", + "loss=2 #Power lossin feed system\n", + "\n", + "\n", + "#Calculation\n", + "adb=10*math.log10(p)\n", + "EIRP=adb+ag-loss\n", + "\n", + "\n", + "#Result\n", + "print(\"Earth station EIRP = %ddB\"%EIRP)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Earth station EIRP = 98dB\n" + ] + } + ], + "prompt_number": 17 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/chapter_5.ipynb b/Satellite_Communication/chapter_5.ipynb new file mode 100644 index 00000000..4834f8d0 --- /dev/null +++ b/Satellite_Communication/chapter_5.ipynb @@ -0,0 +1,618 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "chapter 5: Communication Techniques" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.1, page no-174 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Power Saving'''\n", + "\n", + "import math\n", + "\n", + "\n", + "#for case (a)\n", + "\n", + "#Variable Declaration\n", + "m=0.5 #modulation index\n", + "\n", + "#Calculation\n", + "#for AM\n", + "pt1=(1+(m**2)/2.0)\n", + "#for SSBSC\n", + "pt2=(m**2)/4.0\n", + "#% power saving\n", + "p=(pt1-pt2)*100/pt1\n", + "p=math.floor(p*10)/10\n", + "\n", + "#Result\n", + "print(\"Percentage power saving is %.1f%%\"%p)\n", + "\n", + "#for case (b)\n", + "\n", + "#Variable Declaration\n", + "m=1 #modulation index\n", + "\n", + "#Calculation\n", + "#for AM\n", + "pt1=(1+(m**2)/2.0)\n", + "#for SSBSC\n", + "pt2=(m**2)/4.0\n", + "#% power saving\n", + "p=(pt1-pt2)*100/pt1\n", + "p=math.floor(p*10)/10\n", + "\n", + "#Result\n", + "print(\"\\n Percentage power saving is %.1f%%\"%p)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Percentage power saving is 94.4%\n", + "\n", + " Percentage power saving is 83.3%\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.2, page no-174 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Total power in modulated signal'''\n", + "#Variable Declaration\n", + "pc=500 #energy of carrier signal\n", + "m=0.6 #AM modulation index\n", + "\n", + "\n", + "#Calculation\n", + "\n", + "#for (a)\n", + "pt=pc*(1+(m**2)/2)\n", + "\n", + "#for (b)\n", + "pt2=pc*(m**2)/4\n", + "\n", + "\n", + "#Result\n", + "print(\"(a)\\n A3E is the double side band AM with full carrier.\\n Therefore, Pt= %.0f W\\n\\n (b)\\n J3E is an SSBSC system.\\n Therefore, Pt= %.0f W\"%(pt,pt2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + " A3E is the double side band AM with full carrier.\n", + " Therefore, Pt= 590 W\n", + "\n", + " (b)\n", + " J3E is an SSBSC system.\n", + " Therefore, Pt= 45 W\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.3, page no-175 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Percentage power saving'''\n", + "import math\n", + "#Variable Declaration\n", + "m=0.6 #60% modulation\n", + "\n", + "\n", + "#Calculation\n", + "#for A3E\n", + "pt1=(1+(m**2)/2)\n", + "#for J3E\n", + "pt2=(m**2)/4\n", + "#% power saving\n", + "p=(pt1-pt2)*100/pt1\n", + "p=math.ceil(p*10)/10\n", + "\n", + "#Result\n", + "print(\"Percentage power saving is %.2f%%\"%p)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Percentage power saving is 92.40%\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.4, page no-175 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Carrier frequency in terms of modulating frequency'''\n", + "#Variable Declaration\n", + "#multiplication of two signals gives AM with frequency component(wc-wm) and (wc+wm) and its BW is 2wm\n", + "bw=0.5/100 #bw is 0.5% of carrier freq. \n", + "\n", + "\n", + "#Calculation\n", + "wc=2/bw\n", + "\n", + "#Result\n", + "print(\"Wc = %.0f*Wm\"%wc)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Wc = 400*Wm\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.5, page no-190 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Unmodulated carrier frequency, modulation index, Modulating frequency'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "#comparing given equation with stanard equation\n", + "m=6.0 #Modulation Index\n", + "wc=7.8*10**8 #unmodulated carrier frequency\n", + "wm=1450 #Modulating frequency\n", + "\n", + "\n", + "#Calculation\n", + "fc=wc/(2*math.pi)\n", + "fm=wm/(2*math.pi)\n", + "\n", + "\n", + "#Result\n", + "print(\"Unmodulated carrier frequency, fc = %.2f MHz \\n The modulation index m = %d \\n Modulating frequency, fm = %.2f Hz\"%(fc/10**6,m,fm))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Unmodulated carrier frequency, fc = 124.14 MHz \n", + " The modulation index m = 6 \n", + " Modulating frequency, fm = 230.77 Hz\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.7, page no-191 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''frequency deviation and Bandwidth'''\n", + "#Variable Declaration\n", + "#comparing given equation with stanard equation\n", + "mf=150 #modulation index\n", + "fm=1 # modulating frequency in KHz\n", + "\n", + "\n", + "#Calculation\n", + "fd=mf*fm\n", + "bw=2*(mf+1)*fm\n", + "\n", + "#Result\n", + "print(\"frequency deviation = %.0f kHz\\n Bandwidth = %.0f kHz \\n\\n Expression for instantaneous frequency is given by, \\n f = 10^8-150*(10^3)*sin(2*3.14*10^3*t)\"%(fd,bw))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "frequency deviation = 150 kHz\n", + " Bandwidth = 302 kHz \n", + "\n", + " Expression for instantaneous frequency is given by, \n", + " f = 10^8-150*(10^3)*sin(2*3.14*10^3*t)\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.8, page no-191 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable Declaration\n", + "fd=50 #frequency deviation in kHz\n", + "fm=1.0 #modulating frequency in kHz for case 1\n", + "fm2=100.0 #modulating frequency in kHz for case 2\n", + "\n", + "\n", + "#Calculation\n", + "#for case 1\n", + "m=fd/fm\n", + "bw=2*(m+1)*fm\n", + "#for case 2\n", + "m2=fd/fm2\n", + "bw2=2*(m2+1)*fm2\n", + "\n", + "\n", + "#Result\n", + "print(\"For first case\\n Modulation index = %.0f \\n Bandwidth = %.0f kHz \\n\\n For second case\\n Modulation index = %.1f \\n Bandwidth = %.0f kHz\"%(m,bw,m2,bw2))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.9, page no-192 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''New modulation index and New bandwidth'''\n", + "#Variable Declaration\n", + "bw=20*10**3 #bandwidth in Hz\n", + "fm=1* 10**3 #modulating frequency in Hz\n", + "\n", + "\n", + "#Calculation\n", + "mf=(bw/(2*fm))-1\n", + "new_mf=mf*6\n", + "new_fm=0.5 #kHz\n", + "new_bw=2*(new_mf+1)*new_fm\n", + "\n", + "#Result\n", + "print(\"mf=%.0f\\n New modulation index = %.0f\\n New bandwidth = %.0f kHz\"%(mf,new_mf,new_bw))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "mf=9\n", + " New modulation index = 54\n", + " New bandwidth = 55 kHz\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.10, page no-192" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Deviation Ratio and Bandwidth'''\n", + "\n", + "#Variable Declaration\n", + "fd=75.0 #Maximum allowed frequency deviation in kHz\n", + "fm=15.0 #Highest modulating frequency in kHz\n", + "\n", + "\n", + "#Calculation\n", + "D=fd/fm\n", + "bw=2*(D+1)*fm\n", + "\n", + "#Result\n", + "print(\"Deviation Ratio, D = %.0f\\n Bandwidth = %.0f kHz\"%(D,bw))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Deviation Ratio, D = 5\n", + " Bandwidth = 180 kHz\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.11, page no-199" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''no of bits,no of quantizing levels and samplinf frequecy''' \n", + "import math\n", + "\n", + "#Variable Declaration\n", + "fm=3200.0 #highest frequency component in message signal\n", + "k=48000.0 #channel capacity in b/s\n", + "\n", + "#Calculation\n", + "fs=2*fm\n", + "n=k/fs\n", + "n=math.floor(n)\n", + "\n", + "#Result\n", + "print(\"n = %.0f\\n L = 2^7 = %.0f\\n fs = %.3f kHz\"%(n,2**7,(k/7)/1000))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "n = 7\n", + " L = 2^7 = 128\n", + " fs = 6.857 kHz\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.12, page no-199" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Nyquist rate'''\n", + "#Variable Declaration\n", + "#re-arranging equation and comparing it with standard equation we have,\n", + "f=2500 #Highest frequency component in the signal in Hz\n", + "\n", + "#result\n", + "print(\"Nyquist rate = 2 x f\\n\\t = %.0f Hz = %.0f kHz\"%(2*f,2*f/1000))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Nyquist rate = 2 x f\n", + "\t = 5000 Hz = 5 kHz\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.13, page no-199" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Time duration of one bit'''\n", + "import math\n", + "#Variable Declaration\n", + "l=128 #no of Quantizing levels\n", + "fs=10000.0 #sampling frequency in Hz\n", + "\n", + "\n", + "#Calculation\n", + "n=7 #math.log2(l)\n", + "t=1/(n*fs)\n", + "\n", + "#Result\n", + "print(\"Number of bits per sample (n) = %.0f\\n Time duration of one bit of binary encoded signal is %.3f micro second\"%(n,t*10**6))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Number of bits per sample (n) = 7\n", + " Time duration of one bit of binary encoded signal is 14.286 micro second\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.15, page no-208" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Sampling rate and Sampling interval of the composite signal'''\n", + "f1=2.4 #first signal frequency\n", + "f2=3.2 #2nd signal frequency\n", + "f3=3.4 #3rd signal frequency\n", + "\n", + "#minimum sampling rate for each of the signals would be twice the highest frequency component\n", + "\n", + "\n", + "sr=3*(f3*2)\n", + "st=10**6/(sr*10**3)\n", + "print(\"Sampling rate of the composite signal = %.1f kHz \\nSampling interval of the composite signal = %.0f micro second\"%(sr,st))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sampling rate of the composite signal = 20.4 kHz \n", + "Sampling interval of the composite signal = 49 micro second\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.16, page no-209" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Number of bits in each frame, Bit duration, micro second, Transmission rate'''\n", + "import math\n", + "\n", + "bw=3.2 # voice channel band limited frequency in kHz\n", + "r=1.2 # 1.2 times the Nyquist rate\n", + "n=24.0 # no of voice channel\n", + "b=8.0 # 8-bit PCM\n", + "sr=2*bw*r\n", + "p=10**6/(sr*10**3)\n", + "N=(n*b)+1\n", + "bit_d=p/N\n", + "bit_d=math.ceil(bit_d*1000)/1000\n", + "tr=1/bit_d\n", + "\n", + "print(\"Number of bits in each frame = %.0f \\nBit duration = %.3f micro second \\nTransmission rate = %.3f Mbps\"%(N,bit_d,math.ceil(tr*1000)/1000))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Number of bits in each frame = 193 \n", + "Bit duration = 0.675 micro second \n", + "Transmission rate = 1.482 Mbps\n" + ] + } + ], + "prompt_number": 21 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/chapter_6.ipynb b/Satellite_Communication/chapter_6.ipynb new file mode 100644 index 00000000..f4e3eeff --- /dev/null +++ b/Satellite_Communication/chapter_6.ipynb @@ -0,0 +1,359 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "chapter 6: Multiple Access Techniques" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.1, page no-230" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''length of reference and traffic burst'''\n", + "#Variable Declaration\n", + "t=20 #TDMA frame length in ms\n", + "lc=352 #length of carrier and clock recovery frequency in bits\n", + "lu1=48 #length of unique word in bits\n", + "lo=510 #length of order wire channel in bits\n", + "lm= 256 #length of management channel in bits\n", + "lt=320 # length of transmit timming channel in bits\n", + "ls1=24 # length of service channel in bits\n", + "gt=64 # Guard time in bits\n", + "rb=2 # reference burst\n", + "\n", + "\n", + "#Calculation\n", + "lr=lc+lu1+lo+lm+lt\n", + "tb=lc+lu1+lo+ls1\n", + "tob=(lr*rb)+(tb*t)+((t+rb)*gt)\n", + "\n", + "#Result\n", + "print(\"(a)\\nThe length of reference burst(from given data) is %d bits\\n\\n(b)\\nThe length of traffic burst premable(from given data)is %d bits\\n\\n(c)\\nTotal number of overhead bits is %d bits\"%(lr,tb,tob))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + "The length of reference burst(from given data) is 1486 bits\n", + "\n", + "(b)\n", + "The length of traffic burst premable(from given data)is 934 bits\n", + "\n", + "(c)\n", + "Total number of overhead bits is 23060 bits\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.2, page no-230" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Frame efficiency'''\n", + "import math\n", + "#Variable Declaration\n", + "t=20 # TDMA frame length in ms\n", + "lc=352 # length of carrier and clock recovery frequency in bits\n", + "lu1=48 # length of unique word in bits\n", + "lo=510 # length of order wire channel in bits\n", + "lm=256 # length of management channel in bits\n", + "lt=320 # length of transmit timming channel in bits\n", + "ls1=24 # length of service channel in bits\n", + "gt=64 # Guard time in bits\n", + "rb=2 # reference burst\n", + "br=90.0*10**6 # burst bit rate 90Mbps\n", + "\n", + "\n", + "#Calculation\n", + "bfr=br*t*10**-3\n", + "lr=lc+lu1+lo+lm+lt\n", + "tb=lc+lu1+lo+ls1\n", + "tob=(lr*rb)+(tb*t)+((t+rb)*gt)\n", + "feff=(bfr-tob)*100/bfr\n", + "feff=math.ceil(feff*100)/100\n", + "\n", + "#Result\n", + "print(\"Frame efficiency = %.2f%%\"%feff)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Frame efficiency = 98.72%\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.3, page no-231" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Maximum no of PCM voice channels'''\n", + "import math\n", + "#Variable Declaration\n", + "t=20 # TDMA frame length in ms\n", + "lc=352 # length of carrier and clock recovery frequency in bits\n", + "lu1=48 # length of unique word in bits\n", + "lo=510 # length of order wire channel in bits\n", + "lm= 256 # length of management channel in bits\n", + "lt=320 # length of transmit timming channel in bits\n", + "ls1=24 # length of service channel in bits\n", + "gt=64 # Guard time in bits\n", + "rb=2 # reference burst\n", + "br=90.0*10**6 # burst bit rate 90Mbps\n", + "dr= 64.0*10**3 #data rate 64 kbps\n", + "\n", + "\n", + "#Calculation\n", + "bfr=br*t*10**-3\n", + "lr=lc+lu1+lo+lm+lt\n", + "tb=lc+lu1+lo+ls1\n", + "tob=(lr*rb)+(tb*t)+((t+rb)*gt)\n", + "feff=(bfr-tob)*100/bfr\n", + "feff=math.ceil(feff*100)/100\n", + "vsb=dr*t*10**-3\n", + "x=bfr*feff/100\n", + "\n", + "#Result\n", + "print(\"The number of bits in a frame for a voice sub-burst is %d\\n\\nThe total no of bits available in a frame for carrying traffic is %d\\n\\nMaximum no of PCM voice channels in a frame is %d channels\"%(vsb,x,x/vsb))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The number of bits in a frame for a voice sub-burst is 1280\n", + "\n", + "The total no of bits available in a frame for carrying traffic is 1776960\n", + "\n", + "Maximum no of PCM voice channels in a frame is 1388 channels\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.4, page no-231" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Doppler Shift'''\n", + "import math\n", + "#Variable Declaration\n", + "R=42150.0 # orbital radius of satellite\n", + "oi=0.25/100.0 # orbit inclination\n", + "acc=0.3 # error of 0.3 degree\n", + "c=3.0*10**8 # speed of light\n", + "x=oi*R\n", + "\n", + "\n", + "#Calculation\n", + "x=math.ceil(x*10)/10\n", + "y=R*2*math.pi*acc/360.0\n", + "y=math.ceil(y*10)/10\n", + "z=math.sqrt(x**2+y**2)\n", + "z=math.ceil(z*10)/10\n", + "delay=z*10**6/c\n", + "delay=math.floor(delay*1000)/1000\n", + "pd=2*delay\n", + "\n", + "\n", + "#Result\n", + "print(\"variation in altitude caused by orbit inclination = %.1fkm\\n variation due to station-keeping error of 0.3\u00b0 = %.1fkm\"%(x,y))\n", + "print(\"\\n Both these errors will introduce a maximum range variation of %.1fkm\\n This cause a one-way propagation delay of %.3fms\\n Round trip propagation delay =%.2fms\\n Dopler Shift = %.2f ms in 8h=56.25 ns/s\"%(z,delay,delay*2,pd))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "variation in altitude caused by orbit inclination = 105.4km\n", + " variation due to station-keeping error of 0.3\u00b0 = 220.7km\n", + "\n", + " Both these errors will introduce a maximum range variation of 244.6km\n", + " This cause a one-way propagation delay of 0.815ms\n", + " Round trip propagation delay =1.63ms\n", + " Dopler Shift = 1.63 ms in 8h=56.25 ns/s\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.5, page no-238" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Chip Duration and maximum chip rate'''\n", + "#Variable Declaration\n", + "de=40.0 # Doppler effect variation due to station-keeping errors in ns/s\n", + "d=280.0 # Sttelite round trip delay in ms\n", + "c=20.0/100.0 # DS-CDMA signals should not exceed 20% of the chip duration\n", + "\n", + "#Calculation\n", + "te=de*10**-9*d*10**-3\n", + "tc=te/c\n", + "\n", + "\n", + "#Result\n", + "print(\"Chip Duration, Tc = %.0f ns \\n This gives maximum chip rate as (1/56)Gbps = 1000/56 Mbps = %.3f Mbps\"%(tc*10**9,1000.0/56.0))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Chip Duration, Tc = 56 ns \n", + " This gives maximum chip rate as (1/56)Gbps = 1000/56 Mbps = 17.857 Mbps\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.6, page no-238" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''maximum permissible Dopler effect variation'''\n", + "#Variable Declaration \n", + "cr=25.0 #Chip rate is 25 Mbps\n", + "c=20.0/100.0 # DS-CDMA signals should not exceed 20% of the chip duration\n", + "d=1000/cr #chip duration in ns\n", + "\n", + "\n", + "#Calculation\n", + "tr=c*d\n", + "x=tr/(280.0*10**-3)\n", + "\n", + "#Result\n", + "print(\"The maximum allowable timing error per satellite round trip is %.0f ns\\n This %.0f ns error is to occur in 280 ms.\\n Therefore, maximum permissible Dopler effect variation is %.2f ns/s\"%(tr,tr,x))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The maximum allowable timing error per satellite round trip is 8 ns\n", + " This 8 ns error is to occur in 280 ms.\n", + " Therefore, maximum permissible Dopler effect variation is 28.57 ns/s\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 6.7, page no-238" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Processing gain'''\n", + "import math\n", + "#Variable Declaration\n", + "cr=20.0*10**6 #chip rate in Mbps\n", + "ir= 20.0*10**3 #information bit rate\n", + "\n", + "\n", + "#Calculation\n", + "g=10*math.log10((cr)/(ir))\n", + "\n", + "#Result\n", + "print(\"Noise reduction achhievable = Processing gain = %.0f dB\"%g)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Noise reduction achhievable = Processing gain = 30 dB\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/chapter_7.ipynb b/Satellite_Communication/chapter_7.ipynb new file mode 100644 index 00000000..f48f0b36 --- /dev/null +++ b/Satellite_Communication/chapter_7.ipynb @@ -0,0 +1,761 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "chapter 7: Satellite Link Design Fundamentals" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.1, page no-249" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Power received by the receiving antenna '''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "d=36000 *10**3 #distance of geostationary satellite from earth's surface\n", + "Gt=100 # Antenna gain of 20dB\n", + "Pt=10 # Power radiated by earth station\n", + "\n", + "#Calculation\n", + "Prd=Pt*Gt/(4*math.pi*d**2)\n", + "\n", + "\n", + "#Result\n", + "print(\"Prd = %.4f * 10 ^-12 W/m^2\\nPower received by the receiving antenna is given by Pr = %.3f pW\"%(Prd*10**12,Prd*10**13))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Prd = 0.0614 * 10 ^-12 W/m^2\n", + "Power received by the receiving antenna is given by Pr = 0.614 pW\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.2, page no-262" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''free-space path loss'''\n", + "import math\n", + "#Variable Declaration\n", + "c=3*10**8 #speed of light \n", + "R=10000 #path length\n", + "f=4.0 # operating frequencyin GHz\n", + "EIRP=50 #in dB\n", + "gr=20 #antenna gain in dB\n", + "rp=-120 # received power in dB\n", + "\n", + "\n", + "#Calculation\n", + "\n", + "#(a)\n", + "lamda=c/(f*10**9)\n", + "pl=20*math.log10(4*math.pi*R/lamda)\n", + "\n", + "#(b)\n", + "Lp=EIRP+gr-rp\n", + "\n", + "\n", + "#Result\n", + "print(\"(a)\\n Operating wavelength = %.3f m\\n Path loss(in dB) = %.2f dB\"%(lamda,pl))\n", + "print(\"\\n\\n (b)\\n Path loss = %.0fdB\"%Lp)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + " Operating wavelength = 0.075 m\n", + " Path loss(in dB) = 124.48 dB\n", + "\n", + "\n", + " (b)\n", + " Path loss = 190dB\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.3, page no-262" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Attenuation experienced by coplanar component'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "p=75 # rotation of plane of polarization\n", + "\n", + "#Polarization rotation is inversaly propotional to square of the operating frequency\n", + "\n", + "f= 5.0 #frequency increased by factor \n", + "x=f**2 #rotation angle will decrease by aa factor of 25\n", + "\n", + "\n", + "#Calculation\n", + "k=math.pi/180.0\n", + "p_ex=p/x\n", + "Apr=-20*math.log10(math.cos(p*k))\n", + "Apr2=-20*math.log10(math.cos((p_ex)*k))\n", + "\n", + "\n", + "#Result\n", + "print(\"For polarization mismatch angle = 75\u00b0\\n Attenuation = %.2f dB\"%Apr)\n", + "print(\"\\n\\n For polarization mismatch angle = 3\u00b0 \\n Attenuation = %.3f dB\"%Apr2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For polarization mismatch angle = 75\u00b0\n", + " Attenuation = 11.74 dB\n", + "\n", + "\n", + " For polarization mismatch angle = 3\u00b0 \n", + " Attenuation = 0.012 dB\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.4, page no-270" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Effective noise temperature and System Noise Figure'''\n", + "#Variable Declaration\n", + "g1=30 #gain of RF stage in dB\n", + "t1=20 #Noise temperature in K\n", + "g2=10 #down converter gain in dB\n", + "t2=360 #noise temperature in K\n", + "g3=15 #gain of IF stage in dB\n", + "t3=1000 #noise temperature in K\n", + "t=290 #reference temperature in K\n", + "G1=1000.0 #30 dB equivalent gain\n", + "\n", + "\n", + "#Calculation\n", + "Te=t1+(t2/G1)+t3/(G1*g2)\n", + "F=1+Te/t\n", + "\n", + "\n", + "#Result\n", + "print(\"Effective noise temperature, Te = %.2fK\"%Te)\n", + "print(\"\\n\\nSystem Noise Figure, F = %.2f\"%F)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Effective noise temperature, Te = 20.46K\n", + "\n", + "\n", + "System Noise Figure, F = 1.07\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.5, page no-271" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''overall noise figure'''\n", + "#Variable Declaration\n", + "g1=30 #gain of RF stage in dB\n", + "t1=20 #Noise temperature in K\n", + "g2=10 #down converter gain in dB\n", + "t2=360.0 #noise temperature in K\n", + "g3=15 #gain of IF stage in dB\n", + "t3=1000 #noise temperature in K\n", + "t=290.0 #reference temperature in K\n", + "G1=1000.0 #30 dB equivalent gain\n", + "\n", + "\n", + "#Calculation\n", + "F1=1+t1/t\n", + "F2=1+t2/t\n", + "F3=1+t3/t\n", + "F=F1+((F2-1)/G1)+(F3-1)/(G1*g2)\n", + "\n", + "\n", + "#Result\n", + "print(\"Noise Figure specificatios of the three stages are as follow,\\n\\n F1 = %.3f\\n F2 = %.2f\\n F3 = %.2f\"%(F1,F2,F3))\n", + "print(\"\\n\\n The overall noise figure is, F = %.2f\"%F)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Noise Figure specificatios of the three stages are as follow,\n", + "\n", + " F1 = 1.069\n", + " F2 = 2.24\n", + " F3 = 4.45\n", + "\n", + "\n", + " The overall noise figure is, F = 1.07\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.6, page no-272" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Noise figure'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "L=1.778 #Loss factor of the feeder 2.5dB equivalent\n", + "ts=30 #Noise temperature of sattelite receiver in K\n", + "t=50 #Noise temperature in K\n", + "ti=290.0 # reference temperature in K\n", + "\n", + "\n", + "#Calculation\n", + "x=t/L\n", + "y=ti*(L-1)/L\n", + "Te=x+y+ts\n", + "F1=1+(ts/ti)\n", + "F2=1+(Te/ti)\n", + "\n", + "\n", + "#Result\n", + "print(\"contribution of antenna noise temperature when\\n referred to the input of the receiver is %.1f K\"%x)\n", + "print(\"\\n\\n Contribution of feeder noise when referred to the\\n input of the receiver is %.1f\"%y)\n", + "print(\"\\n\\n1. Noise figure in first case = %.3f = %.3f dB\"%(F1,10*math.log10(F1)))#answer in book is different 0.426dB\n", + "print(\"\\n\\n2. Noise figure in second case = %.3f = %.2f dB\"%(F2,10*math.log10(F2)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "contribution of antenna noise temperature when\n", + " referred to the input of the receiver is 28.1 K\n", + "\n", + "\n", + " Contribution of feeder noise when referred to the\n", + " input of the receiver is 126.9\n", + "\n", + "\n", + "1. Noise figure in first case = 1.103 = 0.428 dB\n", + "\n", + "\n", + "2. Noise figure in second case = 1.638 = 2.14 dB\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.7, page no-272" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Loss factor'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "Ta=40 #Antenna Noise temperature\n", + "Ti=290.0 #Reference temperature in K\n", + "T=50.0 #Effecitve input noise temperatuire\n", + "\n", + "#Calculation\n", + "Tf=Ti\n", + "L=(Ta-Tf)/(T-Tf)\n", + "L=math.ceil(L*10**4)/10**4\n", + "\n", + "#Result\n", + "print(\"Loss factor = %.4f = %.3f dB\"%(L,10*math.log10(L)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loss factor = 1.0417 = 0.177 dB\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.8, page no-273" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''System noise temperature'''\n", + "import math\n", + "\n", + "\n", + "#Variable Declaration\n", + "Ta=50 #Antenna Noise temperature\n", + "Tf=300 #Thermodynamic temperature of the feeder\n", + "Te=50 # Effecitve input noise temperatuire\n", + "\n", + "\n", + "#Calculation for (a)\n", + "Lf=1.0\n", + "T=(Ta/Lf)+(Tf*(Lf-1)/Lf)+Te\n", + "\n", + "#Result for (a)\n", + "print(\"(a)\\n System noise temperature = %.0fK\"%T)\n", + "\n", + "#Calculation for (b)\n", + "Lf=1.413\n", + "T=(Ta/Lf)+(Tf*(Lf-1)/Lf)+Te\n", + "\n", + "#Result for (b)\n", + "print(\"\\n\\n (b)\\n System noise temperature = %.3fK\"%(math.ceil(T*10**3)/10**3))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + " System noise temperature = 100K\n", + "\n", + "\n", + " (b)\n", + " System noise temperature = 173.072K\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.9, page no-278" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''carrier-to-interface ratio'''\n", + "import math\n", + "\n", + "\n", + "#Variable Declaration\n", + "e=35 #EIRP radiated by satellite in dBW\n", + "g=50 #receiver antenna gain in dB\n", + "e1=30 #EIRP of interfacing satellite in dBW\n", + "theeta=4 #line-of-sight between earth station and interfacing sattelite\n", + "\n", + "\n", + "#Calculation\n", + "x=(e-e1)+(g-32+25*math.log10(theeta))\n", + "\n", + "\n", + "#Result\n", + "print(\"carrier-to-interface (C/I) = %.2f dB\"%x)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "carrier-to-interface (C/I) = 38.05 dB\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.10, page no-279" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''carrier-to-interference ratio'''\n", + "import math\n", + "\n", + "\n", + "#Variable Declaration\n", + "ea=80 #EIRP value of earth station A in dBW\n", + "eb=75 #EIRP value of earth station B in dBW\n", + "g=50 #transmit antenna gain in dB\n", + "gra=20 #receiver antenna gain for earth station A in dB\n", + "grb=15 #receiver antenna gain for earth station B in dB\n", + "theeta=4 #viewing angle of the sattelite from two earth station\n", + "\n", + "\n", + "#Calculation\n", + "eirp_d=eb-g+32-25*math.log10(theeta)\n", + "c_by_i=ea-eirp_d+(gra-grb)\n", + "\n", + "\n", + "#Result\n", + "print(\"carrier-to-interference ratio at the satellite due to\\n inteference caused by Eart station B is, (C/I) = %.0f dB \"%c_by_i)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "carrier-to-interference ratio at the satellite due to\n", + " inteference caused by Eart station B is, (C/I) = 43 dB \n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.11, page no-279" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Total carrier-to-interference ratio'''\n", + "import math\n", + "\n", + "\n", + "#Variable Declaration\n", + "\n", + "#carrier sinal strength at sattelite by uplink\n", + "u=10000.0 # equivalent to 40dB\n", + "\n", + "#carrier sinal strength at eart station by downlink \n", + "d=3162.28 #equivalent to 35dB\n", + "\n", + "\n", + "#Calculation\n", + "x=1/((1/u)+(1/d))\n", + "\n", + "\n", + "#Result\n", + "print(\"Total carrier-to-interference ratio is %.2f = %.1f dB\"%(x,10*math.log10(x)))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total carrier-to-interference ratio is 2402.53 = 33.8 dB\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.12, Page no.280" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Longitudinal separation between two satellites'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "theeta=5.0 #Angle form by slant ranges of two satellites\n", + "dA=42100.0*10**3 #Slant range of satellite A\n", + "dB=42000.0*10**3 #Slant range of satellite B\n", + "r=42164.0*10**3 #radius of geostationary orbit\n", + "\n", + "\n", + "#Calculation\n", + "beeta=((dA**2+dB**2-math.cos(theeta*math.pi/180)*2*dA*dB)/(2*r**2))\n", + "beeta=math.ceil(beeta*10**3)/10**3\n", + "beeta=(180/math.pi)*math.acos(1-beeta)\n", + "\n", + "#Result\n", + "print(\"Longitudinal separation between two satellites is %.3f\u00b0\"%beeta)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Longitudinal separation between two satellites is 5.126\u00b0\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.13, Page no.281" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Gain per degree Kelvin'''\n", + "import math\n", + "\n", + "\n", + "#Variable Declaration\n", + "Ga=60.0 #Antenna Gain in dB\n", + "Ta= 60.0 #Noise teperature of Antenna\n", + "L1=1.12 #Feeder Loss equivalent to dB\n", + "T1=290.0 #Noise teperature of stage 1\n", + "G2=10**6 #Gain of stage 2 in dB\n", + "T2=140.0 #Noise teperature of stage 2\n", + "T3=10000.0 #Noise teperature of stage 3\n", + "G=Ga-0.5 #input of low noise amplifier\n", + "\n", + "\n", + "#Calculation\n", + "Ts=(Ta/L1)+(T1*(L1-1)/L1)+T2+(T3/G2)\n", + "Ts=math.floor(Ts*100)/100\n", + "x=G-10*math.log10(Ts)\n", + "\n", + "#Result\n", + "print(\"Tsi = %.2fK\\n\\n G/T(in dB/K)= %.0f dB/K\"%(Ts,x))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Tsi = 224.65K\n", + "\n", + " G/T(in dB/K)= 36 dB/K\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.14, Page no.282" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''Gain per degree Kelvin'''\n", + "import math\n", + "\n", + "#Variable Declaration\n", + "Ga=60.0 #Amplifier Gain in dB\n", + "Ta= 60.0 #Noise teperature of Antenna\n", + "L1=1.12 #Feeder Loss equivalent to dB\n", + "T1=290.0 #Noise teperature of stage 1\n", + "G2=10**6 #Gain of stage 2 in dB\n", + "T2=140.0 #Noise teperature of stage 2\n", + "T3=10000.0 #Noise teperature of stage 3\n", + "G=Ga-0.5 #input of low noise amplifier\n", + "\n", + "\n", + "#Calculation\n", + "T=Ta+T1*(L1-1)+L1*(T2+(T3/G2))\n", + "x=G-10*math.log10(T)\n", + "\n", + "\n", + "#Result\n", + "print(\"T = %.1fK\\n\\n G/T = %.0f dB/k\"%(T,math.ceil(x)))\n", + "print(\"\\n\\n It is evident from the solutions of the problems 13 and 14\\n that G/T ratio is invarient regardless of the reference point in agreement \\n with a statement made earlier in the text.\")\n" + ], + "language": "python", + "metadata": {}, + "outputs": [], + "prompt_number": "*" + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 7.15, Page no.286" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "'''link margin'''\n", + "import math\n", + "#Variable Declaration\n", + "f=6.0*10**9 # uplink frequency\n", + "eirp=80.0 # Earth station EIRP in dBW\n", + "r=35780.0 # Earth station satellite distance\n", + "l=2.0 # attenuation due to atomospheric factors in dB\n", + "e=0.8 # satellite antenna's aperture efficiency\n", + "a=0.5 # satellite antenna's aperture area\n", + "T=190.0 # Satellite receiver's effective noise temperature \n", + "bw=20.0*10**6 # Satellite receiver's bandwidth\n", + "cn=25.0 # received carrier-to-noise ratioin dB\n", + "c=3.0*10**8 # speed of light\n", + "\n", + "#Calculation\n", + "k=1.38*10**-23\n", + "lamda=c/f\n", + "G=e*4*math.pi*a/lamda**2\n", + "G=math.ceil(G*100)/100\n", + "Gd=10*math.log10(G)\n", + "p=10*math.log10(k*T*bw)\n", + "pl=20*math.log10(4*math.pi*r*10**3/lamda)\n", + "rp=eirp-l-pl+Gd\n", + "rp=math.floor(rp*100)/100\n", + "rc=math.floor((rp-p)*100)/100\n", + "lm=rc-cn\n", + "\n", + "#Result\n", + "print(\"Satellite Antenna gain, G = %.2f = %.2f dB \\n Receivers Noise Power = %.1f dB\\n free-space path loss = %.2f dB \\n received power at satellite = %.2f dB \\n receiver carrier = %.2f is stronger than noise.\\n It is %.2f dB more than the required threshold value.\\n Hence, link margin = %.2f dB\"%(G,Gd,p,pl,rp,rc,lm,lm))\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Satellite Antenna gain, G = 2010.62 = 33.03 dB \n", + " Receivers Noise Power = -132.8 dB\n", + " free-space path loss = 199.08 dB \n", + " received power at satellite = -88.05 dB \n", + " receiver carrier = 44.75 is stronger than noise.\n", + " It is 19.75 dB more than the required threshold value.\n", + " Hence, link margin = 19.75 dB\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Satellite_Communication/screenshots/a.png b/Satellite_Communication/screenshots/a.png new file mode 100644 index 00000000..32f78334 Binary files /dev/null and b/Satellite_Communication/screenshots/a.png differ diff --git a/Satellite_Communication/screenshots/b.png b/Satellite_Communication/screenshots/b.png new file mode 100644 index 00000000..ccec2644 Binary files /dev/null and b/Satellite_Communication/screenshots/b.png differ diff --git a/Satellite_Communication/screenshots/c.png b/Satellite_Communication/screenshots/c.png new file mode 100644 index 00000000..84eea621 Binary files /dev/null and b/Satellite_Communication/screenshots/c.png differ -- cgit