{
"metadata": {
"name": ""
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h1> Chpater 3: WAVEFORM CODING TECHNIQUES<h1>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3,1 Page No 110"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print('This is a Theoretical example')\t"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"This is a theoretcal example\n"
]
}
],
"prompt_number": 104
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3,2,i, Page No 111"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math \n",
"#find code word length\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"bandwidth=4.2*10**6\n",
"fm=bandwidth\n",
"q=512 #Quantization levels\n",
"#q=2^v\n",
"\n",
"#Calculation\n",
"v=math.log10(512)/math.log10(2)\n",
"\n",
"#Result\n",
"print(\"The code word legth is = %.f bits\" %v)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The code word legth is = 9 bits\n"
]
}
],
"prompt_number": 105
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.2.ii, Page No 111"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#find The transmission Bandwidth\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"bandwidth=4.2*10**6\n",
"fm=bandwidth\n",
"q=512.0 #Quantization levels\n",
"v=9.0\n",
"\n",
"#Calculation\n",
"bw=v*fm*10**-6\n",
"\n",
"#Result\n",
"print(\"The transmission Bandwidth is = %.1f MHz\" %bw)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"The transmission Bandwidth is = 37.8 MHz\n"
]
}
],
"prompt_number": 106
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.2.iii, Page No 111 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#find Final Bit rate\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"bandwidth=4.2*10**6\n",
"fm=bandwidth\n",
"q=512.0 #Quantization levels\n",
"v=9.0\n",
"\n",
"#Calculation\n",
"fs=2*fm\n",
"r=v*fs #signaling rate\n",
"\n",
"#Result\n",
"print(\"Final Bit rate =%.1f x 10^6 bits/sec\" %(r/(10**6)))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Final Bit rate =75.6 x 10^6 bits/sec\n"
]
}
],
"prompt_number": 107
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.2.iv, Page No 111"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#find Output signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"bandwidth=4.2*10**6\n",
"fm=bandwidth\n",
"q=512 #Quantization levels\n",
"v=9.0\n",
"\n",
"#Calculation\n",
"sn=4.8+6*v #noise in dB\n",
"\n",
"\n",
"print(\"Output signal to noise ratio is = %.1f dB\" %sn)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Output signal to noise ratio is = 58.8 dB\n"
]
}
],
"prompt_number": 108
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.3.i, Page No 112"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#find bits per sample\n",
"\n",
"#Variable Declaration\n",
"fmax=4*10**3\n",
"xmax=3.8\n",
"snr=100\n",
"\n",
"#Calculation\n",
"P=30*10**-3\n",
"v=(math.log10(((snr*xmax**2)/(3*P)))/(2*math.log10(2)))\n",
"\n",
"#Result\n",
"print(\"Number of bits required per sample are = %.2f bits\" %v)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Number of bits required per sample are = 6.98 bits\n"
]
}
],
"prompt_number": 109
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.3.ii, Page No 168"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#Find Transmission Bandwith\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"fm=4*10**3 #Bandwidth of PCM\n",
"xmax=3.8\n",
"snr=100 #Signal to Noise Ratio\n",
"outputs=30.0\n",
"v=7.0\n",
"\n",
"#Calculation\n",
"bw=outputs*v*fm \n",
"r=bw*2\n",
"bw=bw/10**3\n",
"\n",
"#Result\n",
"print('Transmission Bandwith R = %.f kHz' %bw)\n",
"r=r/1000\n",
"print('Signaling rate R = %.f bits/sec' %r)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Transmission Bandwith R = 840 kHz\n",
"Signaling rate R = 1680 bits/sec\n"
]
}
],
"prompt_number": 110
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.4, Page No 112"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#find sampling rate,number of bits,bit rate,bandwidht\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"emax=0.001\n",
"de=2*emax\n",
"fm=100.0\n",
"xmax=10.0\n",
"\n",
"#Calculation\n",
"q=(2*xmax)/de\n",
"fs=2*fm\n",
"v=(math.log10(q))/math.log10(2)\n",
"v=math.ceil(v)\n",
"r=v*fs\n",
"\n",
"#Result\n",
"print('1. sampling Frequncy = %.f Hz ' %fs) \n",
"print('2. No.of bits in PCM = %.f bits ' %v) \n",
"print('3. sampling rate = %.f bits per second ' %r)\n",
"r=r/2\n",
"print('4. Transmission Bandwidth = %.f Hz ' %r) "
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"1. sampling Frequncy = 200 Hz \n",
"2. No.of bits in PCM = 14 bits \n",
"3. sampling rate = 2800 bits per second \n",
"4. Transmission Bandwidth = 1400 Hz \n"
]
}
],
"prompt_number": 111
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.5, Page No 113 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Bandwidth,Sampling Rate\n",
"\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"fm=3.4*10**3\n",
"N=24\n",
"r=1.5*10**6\n",
"encoder=8\n",
"\n",
"#Calculation\n",
"BW=N*fm\n",
"BW=BW/10**3\n",
"r1=r/N\n",
"fs=r1/encoder\n",
"\n",
"#Result\n",
"print(\"i. Channel Bandwith is = %.2f kHz\" %BW)\n",
"print(\"ii. Sampling frequency is = %.2f Hz or samples per second.\" %fs)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i. Channel Bandwith is = 81.60 kHz\n",
"ii. Sampling frequency is = 7812.50 Hz or samples per second.\n"
]
}
],
"prompt_number": 112
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.6, Page No 114 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#Find Signal Bandwidth,Noise Ratio\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"v=7\n",
"r=50*10**6\n",
"\n",
"#Calculation\n",
"#fs=2*fm\n",
"fm=r/(2*v)\n",
"snr=1.8+(6*v);\n",
"fm=fm*10**-6\n",
"\n",
"#Result\n",
"print('i. Maximum message Bandwidth is = %.2f MHz ' %fm)\n",
"print('ii. signal to quantization niose ration = %.2f dB ' %snr)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i. Maximum message Bandwidth is = 3.57 MHz \n",
"ii. signal to quantization niose ration = 43.80 dB \n"
]
}
],
"prompt_number": 113
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.7, Page No 114"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#find i)bits per sample,ii)transmission rate\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"fm=3*10**3\n",
"q=16\n",
"\n",
"#Calculation\n",
"v=(math.log10(q))/math.log10(2)\n",
"\n",
"#Result\n",
"print('i) Bits in code word= %.f bits' %v)\n",
"fs=2*fm\n",
"r=v*fs\n",
"print('ii) it trasmission rate= %.f x 10^3 bits per second' %(r/(10**3)))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Bits in code word= 4 bits\n",
"ii) it trasmission rate= 24 x 10^3 bits per second\n"
]
}
],
"prompt_number": 114
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.8, Page No 115"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#Find signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"fm=3.5*10**3\n",
"r=50*10**3\n",
"\n",
"#Calculation\n",
"fs=2*fm\n",
"rms=0.2\n",
"xmax=2\n",
"v=r/fs #signaling rate r=v*fs\n",
"v=math.ceil(v)\n",
"P=(rms**2)/1\n",
"SNR=((3*P*2**(2*v))/(xmax**2))\n",
"SN=10*math.log10(SNR)\n",
"SN=math.ceil(SN)\n",
"\n",
"#Result\n",
"print(\"signal to niose ratio =%.f dB\" %SN)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"signal to niose ratio =33 dB\n"
]
}
],
"prompt_number": 115
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.10, Page No 117 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find i)noise ratio ii)bits\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"Am=3.0\n",
"v=10.0\n",
"\n",
"#Calculation\n",
"SNR=1.8+6*v #noise ratio \n",
"SN=40\n",
"v=(SN-1.8)/6\n",
"\n",
"#Result\n",
"print(\"i) Signal to Quantization noise ratio = %.1f dB\" %SNR)\n",
"print(\"ii) Bits required to get signal to niose ratio of 40dB = %.f \" %math.ceil(v))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Signal to Quantization noise ratio = 61.8 dB\n",
"ii) Bits required to get signal to niose ratio of 40dB = 7 \n"
]
}
],
"prompt_number": 116
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.11, Page No 117 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Maximum frequency\n",
"\n",
"#Variable Declaration\n",
"#Given data\n",
"v=7\n",
"SNR=1.8+6*v\n",
"r=56*10**3\n",
"\n",
"#Calculation\n",
"fs=r/v #r=v*fs signaling rate\n",
"fm=fs/2 #Nquset rate\n",
"\n",
"#Result\n",
"fm=fm/10**3\n",
"print(\"Maximum frequency is = %.f kHz\" %fm)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Maximum frequency is = 4 kHz\n"
]
}
],
"prompt_number": 117
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.14, Page No 129 "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Maximum Amplitude\n",
"\n",
"#Variable Declaration\n",
"fm=3*10**3.0\n",
"\n",
"#Calculation\n",
"Nyquistrate=2*fm #Nyquistrate\n",
"fs=5*Nyquistrate #Samplingfrquency\n",
"Ts=1/fs #Sampling Interval\n",
"de=0.25 #step size\n",
"fm1=2*10**3.0\n",
"Am=de/(2*math.pi*fm1*Ts)\n",
"\n",
"#Result\n",
"print(\"Maximum Amplitude = %.4f Volts\" %Am)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Maximum Amplitude = 0.5968 Volts\n"
]
}
],
"prompt_number": 118
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.16, Page No 130"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find signaling rate\n",
"\n",
"#Variable Declaration\n",
"fs1=8*10**3.0\n",
"de=31.25*10**-3\n",
"q=64.0\n",
"\n",
"#Calculation\n",
"v=math.log(q,2)\n",
"r=v*fs1 #signaling rate\n",
"fm=3*10**3.0\n",
"A=1\n",
"fs2=(2*math.pi*fm*A)/(de)\n",
"\n",
"#Result\n",
"r=r*10**-3\n",
"print(\"Signaling rate of PCM is = %.f kHz\" %r)\n",
"fs2=fs2*10**-3\n",
"print(\"The signaling rate of DM is = %.2f kHz\" %fs2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Signaling rate of PCM is = 48 kHz\n",
"The signaling rate of DM is = 603.19 kHz\n"
]
}
],
"prompt_number": 119
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.17, Page No 131"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"fs=64.0*10**3 #frequency\n",
"fm=2.0*10**3 #Sinosoidal input signal sample \n",
"fM=4.0*10**3 #bandwidth\n",
"\n",
"#Calculation\n",
"SNR=(3*fs**3)/(8*math.pi**2*fm**2*fM) #Signal to noise ratio\n",
"SNRO=10*math.log10(SNR)\n",
"\n",
"#Result\n",
"print(\"Output signal to noise ratio = %.2f dB\" %SNRO)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Output signal to noise ratio = 27.94 dB\n"
]
}
],
"prompt_number": 120
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.18, Page No 131"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find signal to Quatization noise ratio \n",
"\n",
"#Variable Declaration\n",
"fs=8.0*10**3 #Sampling frequency\n",
"r=64.0*10**3 #Data Rate\n",
"N=8 #number of bits\n",
"\n",
"#Calculation\n",
"SNR=(1.8+6*N) #signal to Quatization noise ratio\n",
"\n",
"#Result\n",
"print(\"Signal to Quatization noise ratio of PCM system is = %.f dB\" %SNR)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Signal to Quatization noise ratio of PCM system is = 50 dB\n"
]
}
],
"prompt_number": 121
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.20, Page No 149"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#Find sampling rate,quantizing level\n",
"\n",
"#Variable Declaration\n",
"r=36000\n",
"fm=3.2*10**3\n",
"\n",
"#Calculation\n",
"fs=2*fm #Nquest rate\n",
"v=r/fs #r=v*fs signaling rate\n",
"v=math.floor(v)\n",
"q=2**v\n",
"fs1=r/v\n",
"\n",
"#Result\n",
"print(\"Quantizing level q = %.f \" %q)\n",
"fs1=fs1/1000\n",
"print(\"sampling rate fs = %.1f kHz \" %fs1)\n",
"print(\"Number of binary digits = %.f \" %v)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Quantizing level q = 32 \n",
"sampling rate fs = 7.2 kHz \n",
"Number of binary digits = 5 \n"
]
}
],
"prompt_number": 122
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.21, Page No 149"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find time duration of 1bit binary encoded signal\n",
"\n",
"#Variable Declaration\n",
"fs=input(\"Enter the Nyquist rate of Signal fs(Hz)=\")\n",
"q=input(\"Enter the Quantization levels q =\")\n",
"\n",
"#Calculation\n",
"v=math.log(q,2) #binary pulses transmitted per second\n",
"t=1.0/(v*fs) #Nyquist interval\n",
"\n",
"#Result\n",
"print('Time duration of binary signal t = %.4f sec ' %t)\n",
"#output\n",
"#Enter the Nyquist rate fs(Hz)=3\n",
"#Enter the Quantization levels q =5\n",
"#time duration of 1bit binary signal \n",
"#t=0.1435589 sec"
],
"language": "python",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"stream": "stdout",
"text": [
"Enter the Nyquist rate of Signal fs(Hz)=23\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"stream": "stdout",
"text": [
"Enter the Quantization levels q =34\n"
]
},
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Time duration of binary signal t = 0.0085 sec \n"
]
}
],
"prompt_number": 123
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.23, Page No 150"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#find signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"SNR=40\n",
"SNRO=10**(SNR/10)\n",
"\n",
"#SNR=3(q**2)/2, Signal to Quantization noise ratio\n",
"\n",
"#Calculation\n",
"q=math.sqrt((2*SNRO)/3)\n",
"q=math.ceil(q)\n",
"v=math.log(q,2) #q=2**v Quantization levels\n",
"v=math.ceil(v)\n",
"snr=1.76+6.02*v #output Signal to Quantization noise ratio\n",
"\n",
"#Result\n",
"print(\"Output Signal to Quantization noise ratio = %.1f dB\" %snr)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Output Signal to Quantization noise ratio = 43.9 dB\n"
]
}
],
"prompt_number": 124
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.24.i, Page No 150"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Quantizing levels,minimum number of bits per sample\n",
"\n",
"#Variable Declaration\n",
"SNRO=30.0\n",
"fmin=300.0\n",
"fmax=3300.0\n",
"fs=80000.0\n",
"\n",
"#Calculation\n",
"#SNRO=1.76+20log10(q)\n",
"q=10**((SNRO-1.76)/20)\n",
"q=math.ceil(q)\n",
"v=math.log(q,2)\n",
"\n",
"#Result\n",
"print('Quantizing levels required is =%.f' %q)\n",
"print('minimum number of bits per sample are=%.1f that is approximately 5' %v)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Quantizing levels required is =26\n",
"minimum number of bits per sample are=4.7 that is approximately 5\n"
]
}
],
"prompt_number": 125
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.24.ii, Page No 150"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find minimum required bandwidth\n",
"\n",
"#Variable Declaration\n",
"SNRO=30.0 #Signal to quantisizing noise ratio\n",
"fmin=300.0 #min frequency band\n",
"fmax=3300.0 #max frequency band\n",
"fs=8000.0 #Sampling rate\n",
"v=5.0 #Minimum number of bits per sample\n",
"\n",
"#Calculation\n",
"fPCM=(v*fs)/2\n",
"fPCM=fPCM/1000\n",
"\n",
"#Result\n",
"print('minimum required bandwidth =%.f kHz' %fPCM)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"minimum required bandwidth =20 kHz\n"
]
}
],
"prompt_number": 126
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.24.iii, Page No 150"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Quantizing levels,minimum number of bits per sample and bandwidth\n",
"\n",
"#Variable Declaration\n",
"SNRO=30.0 #Signal to quantisizing noise ratio\n",
"fmin=300.0 #min frequency band\n",
"fmax=3300.0 #max frequency band\n",
"fs=8000.0 #Sampling rate\n",
"\n",
"#Calculation\n",
"q=10**((SNRO+10.1)/20)\n",
"q=math.ceil(q)\n",
"v=math.log(q,2)\n",
"v=math.ceil(v)\n",
"\n",
"#Result\n",
"print('Quantizing levels need is =%.f' %q)\n",
"print('minimum number of bits per sample is =%.f' %v)\n",
"fPCM=(v*fs)/2\n",
"fPCM=fPCM/1000\n",
"print('minimum required bandwidth =%.f Khz' %fPCM)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Quantizing levels need is =102\n",
"minimum number of bits per sample is =7\n",
"minimum required bandwidth =28 Khz\n"
]
}
],
"prompt_number": 127
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.27, Page No 152"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"\n",
"#determine the Maximum Amplitude,\n",
"\n",
"#Variable Declaration\n",
"de=250*10**-3\n",
"wm=2*math.pi*1000 \n",
"fs=3*10**3\n",
"Ts=1/fs\n",
"\n",
"#Calculation\n",
"Amax=(de*3*fs*2)/(wm) #Amplitude\n",
"SNR=(3.0*((3*6*(10**3))**3))/((8*(math.pi**2)*(10**3)**3))\n",
"\n",
"#Result\n",
"print('Maximum Amplitude= %.1f mV' %(Amax*(10**2)))\n",
"print('Signal to noise ratio = %.2f dB' %(10*math.log10(SNR)))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Maximum Amplitude= 71.6 mV\n",
"Signal to noise ratio = 23.46 dB\n"
]
}
],
"prompt_number": 128
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.29, Page No 153"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of bits per sample\n",
"\n",
"#Variable Declaration\n",
"SNR=20\n",
"averagepower=30*10**-3\n",
"SNRO=10**(SNR/10)\n",
"A=3.8\n",
"\n",
"#SNRO=average signal power/Quatizing power\n",
"#de=(2*A)/L\n",
"\n",
"#Calculation\n",
"L=math.sqrt((SNRO*A**2)/(3*averagepower))\n",
"n=math.log(L,2)\n",
"n=math.ceil(n)\n",
"\n",
"#Result\n",
"print('Bits required per sample =%.f' %n)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Bits required per sample =7\n"
]
}
],
"prompt_number": 129
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.30.i, Page No 153"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Normalized power for quantization noise\n",
"\n",
"#Variable Declaration\n",
"fm=3.0*10.0**3\n",
"v=8.0\n",
"VH=5.0\n",
"VL=-5.0\n",
"q=2**v\n",
"\n",
"#Calculation\n",
"de=(VH-VL)/q\n",
"Nq=de**2/12.0 #quantization noise\n",
"\n",
"#Result\n",
"print('Normalized power for quantization noise =%.2f x 10^-6 W' %(Nq*(10**6)))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Normalized power for quantization noise =127.16 x 10^-6 W\n"
]
}
],
"prompt_number": 130
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.30.ii, Page No 153"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find bit transmission rate\n",
"\n",
"#Variable Declaration\n",
"fm=3*10.0**3\n",
"v=8.0\n",
"VH=5.0\n",
"VL=-5\n",
"q=2**v\n",
"\n",
"#Calculation\n",
"fs=2*fm #Nyquist rate\n",
"r=8*fs/1000\n",
"\n",
"#Result\n",
"print('bit transmission rate %.f K bits/s' %r)\n",
" \n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"bit transmission rate 48 K bits/s\n"
]
}
],
"prompt_number": 131
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.30.iii, Page No 153"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Signal to quantization noise ratio\n",
"\n",
"#Variable Declaration\n",
"Nq=127.15*10**-6\n",
"Meansignal=2\n",
"\n",
"#Calculation\n",
"P=Meansignal/1\n",
"SNR=P/Nq\n",
"SNRq=10*math.log10(SNR)\n",
"\n",
"#Result\n",
"print('Signal to quantization noise ratio %.2f dB ' %SNRq)\n",
" \n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Signal to quantization noise ratio 41.97 dB \n"
]
}
],
"prompt_number": 132
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.31, Page No 154"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find i)SNR ii)output bit rate iii)no.of bits recorded\n",
"\n",
"#Variable Declaration\n",
"N=16.0\n",
"v=16.0\n",
"fs=44.1*10**3\n",
"\n",
"#Calculation\n",
"SNR=1.76+6*N\n",
"bitrate=2*v*fs\n",
"outputbitrate=2*bitrate*10**-6 #including addtional 100% over head\n",
"CD=outputbitrate*3600*10**-3\n",
"\n",
"#Result\n",
"print('i)Out put signal noise ratio =%.2f dB' %SNR)\n",
"print('ii)output bit rate =%.3f Mbits/sec' %outputbitrate)\n",
"print('iii)no.of bits recorded in CD =%.2f gigabits' %CD)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)Out put signal noise ratio =97.76 dB\n",
"ii)output bit rate =2.822 Mbits/sec\n",
"iii)no.of bits recorded in CD =10.16 gigabits\n"
]
}
],
"prompt_number": 133
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.32, Page No 155"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find output SNR\n",
"#Variable Declaration\n",
"fm=1*10.0**3\n",
"fs=32*10**3\n",
"\n",
"#Calculation\n",
"FM=4*10**3 #Bandwidth\n",
"SNR=(3*fs**3)/(8*math.pi**2*fm**2*FM) #SNR\n",
"SNRO=10*math.log10(SNR)\n",
"\n",
"#Result\n",
"print('Output signal to noise ratio %.2f dB' %SNRO)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Output signal to noise ratio 24.93 dB\n"
]
}
],
"prompt_number": 134
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.33.i, Page No 155"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find step size\n",
"\n",
"#Variable Declaration\n",
"fs=64000.0 #samples/sec\n",
"Amax=1.0 #Maximum signal amplitude\n",
"fm=3500.0 #Sample Rate\n",
"\n",
"#Calculation\n",
"de=(2*math.pi*fm*Amax)/fs*1000\n",
"\n",
"#Result\n",
"print('Step Size %.2f mV ' %de)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Step Size 343.61 mV \n"
]
}
],
"prompt_number": 135
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.33ii, Page No 155"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Quantizatio noise power \n",
"#Variable Declaration\n",
"fs=64000.0 #sample Rate\n",
"Amax=1.0 #Maximum signal Amplitude\n",
"fm=3500.0\n",
"\n",
"#Calculation\n",
"de=343.6117*10**-3 #step size\n",
"Nq=de**2/3.0 #Quantizatio noise power\n",
"Nqd=Nq*(fm/fs)*1000\n",
"\n",
"#Result\n",
"print('Quantizatio noise power %.3f mW' %Nqd)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Quantizatio noise power 2.152 mW\n"
]
}
],
"prompt_number": 136
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.33iii, Page No 155"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find SNR\n",
"\n",
"#Variable Declaration\n",
"fs=64000.0\n",
"Amax=1.0\n",
"fm=3500.0\n",
"Nqd=2.1522995*10**-3\n",
"\n",
"#Calculation\n",
"So=Amax**2/2\n",
"SNR=So/Nqd\n",
"SNRO=10*math.log10(SNR)\n",
"\n",
"#Result\n",
"print('Output signal noise ratio dB %.3f dB' %SNRO)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Output signal noise ratio dB 23.661 dB\n"
]
}
],
"prompt_number": 137
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.34, Page No 156"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Assuming signal is sampled at the rate 20% above Nyquist rate\n",
"\n",
"#Variable Declaration\n",
"fm=4.5*10**6\n",
"q=1024.0\n",
"\n",
"#Calculation\n",
"fs=1.2*2*fm #20% above Nyquist rate\n",
"v=math.log(q,2)\n",
"r=v*fs/10**6\n",
"\n",
"#Result\n",
"print('no.of bits/sec = %.f M bit/sec' %r)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"no.of bits/sec = 108 M bit/sec\n"
]
}
],
"prompt_number": 138
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.35, Page No 156"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#assume bandwidth of the singal is 4kHz\n",
"\n",
"#Variable Declaration\n",
"fs=32000.0\n",
"A=2.0\n",
"fm=4000.0\n",
"BW=4000.0\n",
"\n",
"#Calculation\n",
"de=(2*math.pi*fm*A)/fs\n",
"Nq=de**2/3\n",
"SNR=(3*fs**3)/(8*math.pi**2*fm**2*BW)\n",
"\n",
"#Result\n",
"print('i)step size = %.3f M Volt' %de)\n",
"print('ii)noise power = %.3f W' %Nq)\n",
"print('iii)SNR= = %.3f ' %SNR)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)step size = 1.571 M Volt\n",
"ii)noise power = 0.822 W\n",
"iii)SNR= = 19.454 \n"
]
}
],
"prompt_number": 139
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.36, Page No 157"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#assuming signal is sampled at the rate 20% above Nyquist rate\n",
"\n",
"#Variable Declaration\n",
"fm=15*10**3\n",
"fs=1.2*2*fm\n",
"q=65536\n",
"\n",
"#Calculation\n",
"v=math.log(q,2)\n",
"r=v*fs/1000\n",
"BW=r/2\n",
"\n",
"#Result\n",
"print('i)signaling rate,= %.f K bits/sec ' %r)\n",
"print('ii)bandwidth BW min = %.f kHz ' %BW)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)signaling rate,= 576 K bits/sec \n",
"ii)bandwidth BW min = 288 kHz \n"
]
}
],
"prompt_number": 140
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.37, Page No 157"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find step size,noise power\n",
"\n",
"#Variable Declaration\n",
"fs=64*10**3\n",
"fm=3500.0\n",
"A=1.0\n",
"\n",
"#Calculation\n",
"de=(2*math.pi*fm*A)/fs #step size\n",
"Nq=(de**2/3)*(fm/fs) #Granular noise power\n",
"\n",
"#Result\n",
"print('i)step size = %.3f Volts' %de)\n",
"print('ii)Nq= %.5f W' %Nq)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)step size = 0.344 Volts\n",
"ii)Nq= 0.00215 W\n"
]
}
],
"prompt_number": 141
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.40, Page No 159"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find step Nr,Transmission Bandwidth, SNR\n",
"\n",
"#Variable Declaration\n",
"fs=4 #kHz\n",
"N=12\n",
"\n",
"#Calculation\n",
"Nr=2*fs #Nyquest rate\n",
"Bt=1.0/2*N*fs #Transmission Bandwidth\n",
"SNR=1.8+(6*N) \n",
"\n",
"\n",
"#Result\n",
"print('i)Nyquest rate = %.1f kHz' %Nr)\n",
"print('ii)Transmission Bandwidth = %.1f kHz' %Bt)\n",
"print('iii)SNR = %.1f dB' %SNR)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)Nyquest rate = 8.0 kHz\n",
"ii)Transmission Bandwidth = 24.0 kHz\n",
"iii)SNR = 73.8 dB\n"
]
}
],
"prompt_number": 142
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.41, Page No 159"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find step size,noise power\n",
"\n",
"#Variable Declaration\n",
"fm=3.5*10**3\n",
"fs=64*10**3\n",
"A=2.0\n",
"\n",
"#Calculation\n",
"de=(2*math.pi*fm*A)/fs #step size\n",
"Nq=(de**2/3)*(fm/fs) #Granular noise power\n",
"\n",
"#Result\n",
"print('i)step size = %.3f Volts' %de)\n",
"print('ii)Nq= %.1f X 10^-3 W' %(Nq*10**3))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i)step size = 0.687 Volts\n",
"ii)Nq= 8.6 X 10^-3 W\n"
]
}
],
"prompt_number": 143
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.42, Page No 159"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of binay pulse per word, Bit rate, Bandwidth\n",
"\n",
"#Variable Declaration\n",
"W=4.5 * 10**6 #khz\n",
"Nr = 2 * W #Nyquist Rate\n",
"Q = 1024\n",
"fs=10.8\n",
"\n",
"#Calculation\n",
"N = math.log(Q,2) #number of binay pulse per word\n",
"Br= N*fs #Bit rate\n",
"Bw= 1.0/2*Br #Bandwidth\n",
"\n",
"#Result\n",
"print('i) Number of binay pulse per word = %.1f k bits/sec' %N)\n",
"print('ii) Bit rate = %.1f k bits/sec' %Br)\n",
"print('iii)Bandwidth= %.1f X 10^-3 kHz' %Bw)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of binay pulse per word = 10.0 k bits/sec\n",
"ii) Bit rate = 108.0 k bits/sec\n",
"iii)Bandwidth= 54.0 X 10^-3 kHz\n"
]
}
],
"prompt_number": 144
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.43, Page No 160"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of binay pulse per word, Bit rate, Bandwidth\n",
"\n",
"#Variable Declaration\n",
"W=15 #khz\n",
"Nr = 2*W #Nyquist Rate\n",
"Q = 65.53\n",
"fs=44.1 # Sampling rate kHz\n",
"N=16\n",
"\n",
"#Calculation\n",
"Br= N*fs #Bit rate\n",
"Bw= 1.0/2*Br #Bandwidth\n",
"\n",
"#Result\n",
"print('i) Number of binay pulse per word = %.3f bits' %N)\n",
"print('ii) Bit rate = %.1f k bits/sec' %Br)\n",
"print('iii)Bandwidth= %.1f kHz' %Bw)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of binay pulse per word = 16.000 bits\n",
"ii) Bit rate = 705.6 k bits/sec\n",
"iii)Bandwidth= 352.8 kHz\n"
]
}
],
"prompt_number": 145
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.44, Page No 160"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Number of binay pulse per word\n",
"\n",
"#Variable Declaration\n",
"W=3.3 #khz\n",
"fm = 1*10**3 #kHz\n",
"de = 250 #mV\n",
"fs=19.8 # Sampling rate kHz\n",
"\n",
"#Calculation\n",
"A=(de*fs)/(2*math.pi*fm)\n",
"\n",
"#Result\n",
"print('i) Number of binay pulse per word = %.3f' %A)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of binay pulse per word = 0.788\n"
]
}
],
"prompt_number": 146
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.45, Page No 160"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of binay pulse per word, Signaling rate, Bandwidth\n",
"\n",
"#Variable Declaration\n",
"W=3.3 #khz\n",
"fm = 3300 #Hz\n",
"Snq = 40 #dB\n",
"fs= 8000 # Samples/sec\n",
"\n",
"#Calculation \n",
"N=math.ceil((Snq-4.8)/6) # Number of bits per word\n",
"Q=2**N #\n",
"r=N*fs #Signaling rate k bits/sec\n",
"Bw=1.0/2*r\n",
"\n",
"#Result\n",
"print('i) Number of bits per word = %.1f' %N)\n",
"print('ii) Signaling rate rate = %.1f k bits/sec' %(r/10**3))\n",
"print('iii)Bandwidth= %.1f kHz' %(Bw/10**3))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of bits per word = 6.0\n",
"ii) Signaling rate rate = 48.0 k bits/sec\n",
"iii)Bandwidth= 24.0 kHz\n"
]
}
],
"prompt_number": 147
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.46, Page No 161"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find the maximun frequency with 1 volt amplitude\n",
"\n",
"#Variable Declaration\n",
"de=256*10**-3 #V\n",
"Ts = 10*10**-6 #kHz\n",
"fm = 10 #kHz\n",
"fs= 100 # kHz\n",
"A=1 #V\n",
"\n",
"#Calculation \n",
"wm=(de/A*Ts)*10**7\n",
"\n",
"#Result\n",
"print('i) maximun frequency = %.1f X 10^3 rad/sec' %wm)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) maximun frequency = 25.6 X 10^3 rad/sec\n"
]
}
],
"prompt_number": 148
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.47, Page No 162"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find the Signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"Q=256 \n",
"m=255\n",
"\n",
"#Calculation \n",
"SNR=(3*Q**2)/(math.log((1+m),math.e))**2 #dB\n",
"Gc=m/(math.log(1+m)) #Companding gain\n",
"Gc=20*math.log(Gc,10)\n",
"\n",
"#Result\n",
"print('i) The Signal to noise ratio= %.1f dB' %SNR)\n",
"print('ii) The Companding gain = %.1f dB' %Gc)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) The Signal to noise ratio= 6394.0 dB\n",
"ii) The Companding gain = 33.3 dB\n"
]
}
],
"prompt_number": 149
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.48, Page No 162"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of binay pulse per word, Signaling rate, Bandwidth\n",
"\n",
"#Variable Declaration\n",
"fm=15*10**3 #kHz\n",
"Q=200\n",
"fs=2*fm\n",
"\n",
"#Calculation \n",
"N=math.ceil(math.log(Q,2))\n",
"tr=N*fs #Transmission rate kbps\n",
"Bw=1.0/2*tr\n",
"\n",
"#Result\n",
"print('i) Number of bits per Samples = %.1f' %N)\n",
"print('ii) Signaling rate = %.1f k bits/sec' %(tr/10**3))\n",
"print('iii)Bandwidth= %.1f kHz' %(Bw/10**3))\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of bits per Samples = 8.0\n",
"ii) Signaling rate = 240.0 k bits/sec\n",
"iii)Bandwidth= 120.0 kHz\n"
]
}
],
"prompt_number": 150
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.49, Page No 162"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find number of quantization level\n",
"\n",
"#Variable Declaration\n",
"tr=36.0 #kbps\n",
"fm=3.4 #kHz\n",
"fs=8\n",
"\n",
"#Calculation \n",
"N=math.ceil(tr/fs)\n",
"Q=2**N\n",
"\n",
"\n",
"#Result\n",
"print('i) number of quantization level = %.1f' %Q)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) number of quantization level = 32.0\n"
]
}
],
"prompt_number": 151
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.50, Page No 162"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find delta modulation\n",
"\n",
"#Variable Declaration\n",
"A=1 #V\n",
"fm=3.4 #kHz\n",
"fs=20\n",
"\n",
"#Calculation \n",
"de=1*2*math.pi*(fm/fs)\n",
"\n",
"\n",
"#Result\n",
"print('i) delta modulation = %.2f V' %de)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) delta modulation = 1.07 V\n"
]
}
],
"prompt_number": 152
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.51, Page No 163"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"W=3.5 #kHz\n",
"r=50.0 #kbps\n",
"Vpp=4 #V\n",
"fs=8\n",
"\n",
"#Calculation \n",
"N=r/fs\n",
"SNR=4.8+(6.8*N)\n",
"\n",
"#Result\n",
"print('i) Signal to noise ratio = %.2f V' %SNR)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Signal to noise ratio = 47.30 V\n"
]
}
],
"prompt_number": 153
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Example 3.52, Page No 163"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import math\n",
"#Find Signal to noise ratio\n",
"\n",
"#Variable Declaration\n",
"W=1 #MHz\n",
"fs1=3 #MHz\n",
"fs2=2.4 #MHz\n",
"Q=256\n",
"m=255\n",
"\n",
"#Calculation \n",
"SNR=((3*Q**2)/(math.log((1+m),math.e))**2)\n",
"SNR1=63095.73 #SNR=38+10\n",
"Q1=math.sqrt((SNR1*((math.log(256,math.e))**2))/3)\n",
"N1=math.ceil(math.log(Q1,2))\n",
"r=N1*fs2\n",
"Bw=1.0/2*r\n",
"\n",
"#Result\n",
"print('i) Number of bits/word = %.2f ' %N1)\n",
"print('ii) Bit rate = %.1f Mb/s' %r)\n",
"print('iii) Bandwidth = %.1f Mb/s' %Bw)\n"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"i) Number of bits/word = 10.00 \n",
"ii) Bit rate = 24.0 Mb/s\n",
"iii) Bandwidth = 12.0 Mb/s\n"
]
}
],
"prompt_number": 154
}
],
"metadata": {}
}
]
}