diff options
| author | Jovina Dsouza | 2014-06-18 12:43:07 +0530 |
|---|---|---|
| committer | Jovina Dsouza | 2014-06-18 12:43:07 +0530 |
| commit | 206d0358703aa05d5d7315900fe1d054c2817ddc (patch) | |
| tree | f2403e29f3aded0caf7a2434ea50dd507f6545e2 /Satellite_Communication | |
| parent | c6f0d6aeb95beaf41e4b679e78bb42c4ffe45a40 (diff) | |
| download | Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.tar.gz Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.tar.bz2 Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.zip | |
adding book
Diffstat (limited to 'Satellite_Communication')
| -rw-r--r-- | Satellite_Communication/README.txt | 10 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_2.ipynb | 838 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_3.ipynb | 761 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_4.ipynb | 642 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_5.ipynb | 618 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_6.ipynb | 359 | ||||
| -rw-r--r-- | Satellite_Communication/chapter_7.ipynb | 761 | ||||
| -rw-r--r-- | Satellite_Communication/screenshots/a.png | bin | 0 -> 170436 bytes | |||
| -rw-r--r-- | Satellite_Communication/screenshots/b.png | bin | 0 -> 241075 bytes | |||
| -rw-r--r-- | Satellite_Communication/screenshots/c.png | bin | 0 -> 220776 bytes |
10 files changed, 3989 insertions, 0 deletions
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 Binary files differnew file mode 100644 index 00000000..32f78334 --- /dev/null +++ b/Satellite_Communication/screenshots/a.png diff --git a/Satellite_Communication/screenshots/b.png b/Satellite_Communication/screenshots/b.png Binary files differnew file mode 100644 index 00000000..ccec2644 --- /dev/null +++ b/Satellite_Communication/screenshots/b.png diff --git a/Satellite_Communication/screenshots/c.png b/Satellite_Communication/screenshots/c.png Binary files differnew file mode 100644 index 00000000..84eea621 --- /dev/null +++ b/Satellite_Communication/screenshots/c.png |
