{ "metadata": { "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "heading", "level": 1, "metadata": {}, "source": [ "Chapter 6: Induction Motor Drives" ] }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.1,Page No:147" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the Y-connected induction motor \n", "f=50 # frequency in HZ\n", "Vl=440 #line voltage in V\n", "P=6 # number of poles\n", "N=950 #speed in rpm\n", "\n", "#parameters referred to the stator\n", "Xr_=1.2 # rotor winding reactance in ohm\n", "Rr_=0.4 # resistance of the rotor windings in ohm\n", "Rs=0.5 # resistance of the stator windings in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Xm=50 # no load reactance\n", " \n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "s=(Ns-N)/Ns #full load slip\n", "x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2) #total impedance\n", "Ir_=(Vl/math.sqrt(3))/x #full load rotor current\n", "angle=-math.atan((Xs+Xr_)/(Rs+Rr_/s)) #angle in radian\n", "Ir_=cmath.rect(Ir_,angle) #full load rotor current in rectangular form\n", "Im=Vl/math.sqrt(3)/Xm*(-1j) #magnetizing current\n", "Is=Ir_+Im #full load current\n", "\n", "Zf=Rs+Xs*1j+1j*Xm*(Rr_/s+1j*Xr_)/(Rr_/s+1j*(Xr_+Xm))\n", "Zb=Rs+Xs*1j+1j*Xm*(Rr_/(2-s)+1j*Xr_)/(Rr_/(2-s)+1j*(Xr_+Xm))\n", "Z=Zf+Zb\n", "I=(Vl/math.sqrt(3))/abs(Z) #motor current\n", "Wms=2*math.pi*Ns/60\n", "\n", "#torque due to positive sequence\n", "Tp=(1/Wms)*(3*I**2*Xm**2*Rr_/s)/((Rr_/s)**2+(Xr_+Xm)**2)\n", "#torque due to negative sequence\n", "Tn=-(1/Wms)*(3*I**2*Xm**2*Rr_/(2-s))/((Rr_/(2-s))**2+(Xr_+Xm)**2)\n", "T=Tp+Tn #net torque\n", "Wm=Wms*(1-s) #rated speed in in rad/sec\n", "Tl=0.0123*Wm**2 #required torque of the load\n", "\n", "#results\n", "print\"Full load motor current Is:\",round(abs(Is),1),round(math.degrees(cmath.phase(Is))),\"\u00b0\",\"A\"\n", "print\"Tp:\",round(Tp,2),\"N-m\"\n", "print\"Tn:\",round(Tn,3),\"N-m\"\n", "print\"\\nSince I:\",round(I,2),\"A and N:\",N,\"rpm\"\n", "print\"And I:\",round(I,2),\"A <\",\"Is:\",round(abs(Is),2),\"A, the motor will run safely\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Full load motor current Is: 30.5 -25.0 \u00b0 A\n", "Tp: 125.61 N-m\n", "Tn: -3.299 N-m\n", "\n", "Since I: 24.26 A and N: 950 rpm\n", "And I: 24.26 A < Is: 30.54 A, the motor will run safely\n" ] } ], "prompt_number": 197 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.2,Page No:156" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the Delta connected Induction motor\n", "f=50 #frequency in HZ\n", "Vl=2200 #line voltage in V\n", "P=8 #number of poles\n", "N=735 #rated speed in rpm\n", "#parameters referred to the stator\n", "Xr_=0.55 # rotor winding reactance in ohm\n", "Xs=0.45 # stator winding reactance in ohm\n", "Rr_=0.1 # resistance of the rotor windings in ohm\n", "Rs=0.075 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "s=(Ns-N)/Ns #full load slip\n", "x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2) #total impedance\n", "Ip=(Vl)/x #full load phase current\n", "Il=math.sqrt(3)*Ip #full load line current\n", "Wms=2*math.pi*Ns/60 \n", "Tl=(1/Wms)*(3*Ip**2*Rr_/s) #full load torque\n", "\n", "#(i)if the motor is started by star-delta switching\n", "y=math.sqrt((Rs+Rr_)**2+(Xs+Xr_)**2)\n", "Ist=(Vl/math.sqrt(3))/y #Maximum line current during starting\n", "Tst=(1/Wms)*(3*Ist**2*Rr_) #Starting torque\n", "ratio1=Tst/Tl #ratio of starting torque to full load torque\n", "z=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)\n", "Tmax=3/(2*Wms)*(Vl/math.sqrt(3))**2/z #maximum torque\n", "ratio2=Tmax/Tl #ratio of maximum torque to full load torque\n", "\n", "#(ii) If the motor is started using auto transformer\n", "y=math.sqrt((Rs+Rr_)**2+(Xs+Xr_)**2)\n", "Ist1=Vl*math.sqrt(3)/y #starting current direct online\n", "aT=math.sqrt(2*Il/Ist1) #transofrmation ratio\n", "Ilst=2*Il/aT #starting motor line current\n", "Ipst=Ilst/math.sqrt(3) #starting motor phase current\n", "Tst1=(1/Wms)*(3*Ipst**2*Rr_) #starting torque\n", "\n", "#(iii) If motor is started using part winding method\n", "Rs_=2*Rs\n", "Xs_=2*Xs\n", "y=math.sqrt((Rs_+Rr_)**2+(Xs_+Xr_)**2)\n", "Ist2=(Vl*math.sqrt(3))/y #starting line current \n", "Ip=Ist2/math.sqrt(3) #starting phase current\n", "Tst2=(1/Wms)*(3*Ip**2*Rr_) #starting torque\n", "\n", "#(iv) motor is started using series reactors in line\n", "Rs_=Rs/3 ; Rr_=Rr_/3\n", "Xs_=Xs/3 ; Xr_=Xr_/3\n", "Il=2*Il #line current at start\n", "x=(Vl/math.sqrt(3))**2/(Il**2) #x=(Rs_+Rr_)**2+(Xs_+Xr_+Xe)**2\n", "y=x-(Rs_+Rr_)**2 #y=(Xs_+Xr_+Xe)**2\n", "z=math.sqrt(y) #z=(Xs_+Xr_+Xe)\n", "Xe=z-Xs_-Xr_\n", "\n", "\n", "#results\n", "print\"(i)Maximum value of line current during starting Ist:\",round(Ist),\"A\"\n", "print\" Ratio of starting torque to full load torque :\",round(ratio1,3)\n", "print\" Ratio of maximum torque to full load torque :\",round(ratio2,2)\n", "print\"\\n(ii)transofrmation ratio aT:\",round(aT,3)\n", "print\" starting torque :\",round(Tst1),\"N-m\"\n", "#answer for the starting torque in the book is wrong due to accuracy\n", "print\"\\n(iii)maixmum line current during starting :\",round(Ist2),\"A\"\n", "print\" Starting torque :\",round(Tst2),\"N-m\"\n", "#answer for the starting torque in the book is wrong due to accuracy\n", "print\"\\n(iv)value of the reactor Xe:\",round(Xe,3),\"ohm\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Maximum value of line current during starting Ist: 1251.0 A\n", " Ratio of starting torque to full load torque : 0.173\n", " Ratio of maximum torque to full load torque : 0.83\n", "\n", "(ii)transofrmation ratio aT: 0.627\n", " starting torque : 7041.0 N-m\n", "\n", "(iii)maixmum line current during starting : 2590.0 A\n", " Starting torque : 8539.0 N-m\n", "\n", "(iv)value of the reactor Xe: 0.527 ohm\n" ] } ], "prompt_number": 199 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.3,Page No:159" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor\n", "f=50 # frequency in HZ\n", "Vl=400 # line voltage in V\n", "P=6 # number of poles\n", "#parameters referred to the stator\n", "Xr_=2 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=1 # resistance of the rotor windings in ohm\n", "Rs=Rr_ # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "Wms=2*math.pi*Ns/60 \n", "\n", "#(i)\n", "Sm=-Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2) #slip at maximum torque\n", "x=math.sqrt((Rs+Rr_/Sm)**2+(Xs+Xr_)**2)\n", "Ir_=(Vl/math.sqrt(3))/x #current at maximum torque \n", "Tmax=(1/Wms)*3*Ir_**2*Rr_/Sm #maximum torque\n", "N=(1-Sm)*Ns #range of speed\n", "\n", "#(ii)an overhauling torque of 100Nm\n", "Tl=100 #overhauling torque in Nm\n", "# Tl=(3/Wms)*(Vl**2*Rr_/s)/y\n", "# where y=(Rs+Rr_/s)**2+(Xs+Xr_)**2\n", "a=(1/Wms)*(Vl**2*Rr_)/(-Tl) #a=s*(Rs+Rr_/s)**2+(Xs+Xr_)**2\n", "a = 17\n", "b = 17.3\n", "c = 1\n", "# calculate the discriminant\n", "d = (b**2) - (4*a*c)\n", "# find two solutions\n", "s1 = (-b-cmath.sqrt(d))/(2*a)\n", "s2 = (-b+cmath.sqrt(d))/(2*a)\n", "\n", "N2=(1-s2)*Ns #motor speed and we neglect s1 \n", "\n", "#slight difference in the answer due to accuracy\n", "\n", "#(iii)when a capacitive reactance of 2 ohm is inserted in each phase stator\n", "Xc=2 #reactance of the capacitor\n", "Sm=-Rr_/math.sqrt(Rs**2+(Xs+Xr_-Xc)**2) #slip at maximum torque \n", "x=math.sqrt((Rs+Rr_/Sm)**2+(Xs+Xr_-Xc)**2)\n", "Ir_=(Vl/math.sqrt(3))/x #current at maximum torque \n", "Tmax_=(1/Wms)*3*Ir_**2*Rr_/Sm #maximum overhauling torque with capacitor\n", "ratio=Tmax_/Tmax\n", "\n", "\n", "#results\n", "print\"(i)Maximum overhauling torque that the motor can hold is:\",round(abs(Tmax),1),\"N-m\"\n", "print\" Range of speed is from \",Ns,\"to\",round(N),\"rpm\"\n", "print\"\\n(ii)Now s*(1+1/s)**2+16s=\",a\n", "print\" Or 17s**s+17.3s+1=0\"\n", "print\"The solution for s are \",round(s1.real,3),\"and\",round(s2.real,3)\n", "print\"\\nTherefore Motor speed is: \",round(abs(N2)),\"rpm\"\n", "print\"Note :There is a slight difference in the answer due to the decimal place\"\n", "print\"\\n(iii) Ratio of maximum torque with capacitor and to maximum torque without capacitor is:\",round(ratio,2)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Maximum overhauling torque that the motor can hold is: 244.6 N-m\n", " Range of speed is from 1000.0 to 1243.0 rpm\n", "\n", "(ii)Now s*(1+1/s)**2+16s= 17\n", " Or 17s**s+17.3s+1=0\n", "The solution for s are -0.956 and -0.062\n", "\n", "Therefore Motor speed is: 1062.0 rpm\n", "Note :There is a slight difference in the answer due to the decimal place\n", "\n", "(iii) Ratio of maximum torque with capacitor and to maximum torque without capacitor is: 2.53\n" ] } ], "prompt_number": 202 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.4,Page No:162\n" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the motor is same as that of Ex-6.3\n", "f=50 # frequency in HZ\n", "Vl=400 #line voltage in V\n", "P=6 # number of poles\n", "#parameters referred to the stator\n", "Xr_=2 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=1 # resistance of the rotor windings in ohm\n", "Rs=Rr_ # resistance of the stator windings in ohm\n", "N=950 #full load speed in rpm\n", "SR=2.3 #stator to rotor turns ratio\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "Wms=2*math.pi*Ns/60 \n", "s=(Ns-N)/Ns #full load slip\n", "x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2)\n", "Irf_=(Vl/math.sqrt(3))/x #full load current\n", "Tf=(1/Wms)*3*Irf_**2*Rr_/s #full load torque\n", "\n", "#(i)initial braking current and torque\n", "S=2-s #during plugging at 950rpm\n", "y=math.sqrt((Rs+Rr_/S)**2+(Xs+Xr_)**2)\n", "Ir_=(Vl/math.sqrt(3))/y #initial braking current\n", "ratio1=Ir_/Irf_\n", "T=(1/Wms)*3*Ir_**2*Rr_/S #initial braking torque\n", "ratio2=T/Tf\n", "\n", "#(ii)when an external resistance is connected such \n", "#that maximum braking current is 1.5 times the full load current\n", "Ir_=1.5*Irf_\n", "x=(Vl/math.sqrt(3))/Ir_ #x=math.sqrt((Rs+(Rr_+Re_)/S)**2+(Xs+Xr_)**2)\n", "y=x**2 #y=(Rs+(Rr_+Re_)/S)**2+(Xs+Xr_)**2\n", "z=y-(Xs+Xr_)**2 #z=(Rs+(Rr_+Re_)/S)**2\n", "a=math.sqrt(z) #a=(Rs+(Rr_+Re_)/S)\n", "b=(a-Rs)*S #b=(Rr_+Re_)\n", "Re_=b-Rs\n", "Re=Re_/SR**2\n", "T=(1/Wms)*3*Ir_**2*(Rr_+Re_)/S #initial braking torque\n", "ratio=T/Tf\n", "\n", "\n", "#results\n", "print\"(i)Ratio of initial braking current to full load current is:\",round(ratio1)\n", "print\" Ratio of initial braking torque to full load torque is:\",round(ratio2,2)\n", "print\"\\n(ii)Ratio of initial braking torque to full load torque when the resistance is added is:\",round(ratio,3)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Ratio of initial braking current to full load current is: 5.0\n", " Ratio of initial braking torque to full load torque is: 0.64\n", "\n", "(ii)Ratio of initial braking torque to full load torque when the resistance is added is: 1.426\n" ] } ], "prompt_number": 203 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.5,Page No:165" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor\n", "f=50 # frequency in HZ\n", "Vl=440 # line voltage in V\n", "P=6 # number of poles\n", "Vp=Vl/math.sqrt(3) #phase voltage\n", "#parameters referred to the stator\n", "Xr_=1.2 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=0.4 # resistance of the rotor windings in ohm\n", "Rs=0.5 # resistance of the stator windings in ohm\n", "Xm=50 # no load reactance\n", "N=950 # full load speed\n", "Sm=2 # slip at maximum torque\n", "\n", "#calculation\n", "Rr_=Sm*math.sqrt(Rs**2+(Xs+Xr_)**2) #Since Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2)\n", "Ns=120*f/P #synchronous speed in rpm\n", "Wms=2*math.pi*Ns/60 \n", "s=(Ns-N)/Ns #slip at 950 rpm\n", "\n", "x=1j*Xm*(Rr_/s+1j*Xr_)\n", "y=Rr_/s+1j*(Xr_+Xm)\n", "Zp=Rs+1j*Xs+x/y\n", "Ip=Vp/math.sqrt(3)/Zp #In the book the value of Ip is wrong which leads to other subsequent wrong answers in the book\n", "Irp_=Ip*(1j*Xm)/(Rr_/s+1j*(Xr_+Xm))\n", "Tp=(1/Wms)*3*abs(Irp_)**2*Rr_/s\n", "x=1j*Xm*(Rr_/(2-s)+1j*Xr_)\n", "y=Rr_/(2-s)+1j*(Xr_+Xm)\n", "Zn=Rs+1j*Xs+x/y\n", "In=Vp/math.sqrt(3)/Zn\n", "Irn_=In*(1j*Xm)/(Rr_/(2-s)+1j*(Xr_+Xm))\n", "Tn=-(1/Wms)*3*abs(Irn_)**2*Rr_/(2-s) #In the book the value of In is wrong\n", "\n", "T=Tp-Tn\n", "I=abs(Ip)+abs(In)\n", "Rr_=0.4 # from the parameters of the motor referred to the stator\n", "x=math.sqrt((Rs+Rr_/s)**2+(Xs+Xr_)**2)\n", "If=(Vl/math.sqrt(3))/x #full load current\n", "Tf=(1/Wms)*3*If**2*Rr_/s #full load torque\n", "\n", "ratio1=I/If\n", "ratio2=abs(T)/Tf\n", "\n", "#results\n", "print\"Ratio of braking current to full load current is:\",round(ratio1,3)\n", "print\"Ratio of braking torque to full load torque is:\",round(ratio2,3)\n", "#answer in the book is wrong\n" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Ratio of braking current to full load current is: 1.448\n", "Ratio of braking torque to full load torque is: 0.565\n" ] } ], "prompt_number": 204 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.6,Page No:171" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "from array import array\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.cbook as cbook\n", "%matplotlib inline\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor which operates under dynamic braking\n", "f=50 # frequency in HZ\n", "P=4 # number of poles\n", "#parameters referred to the stator\n", "Xr_=3.01 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=4.575 # resistance of the rotor windings in ohm\n", "Rs=1.9 # resistance of the stator windings in ohm\n", "J=0.1 # moment of inertia of the motor load system in kg-m2\n", "Id=12 # given DC current\n", "\n", "N=1500 #given asynchronous speed\n", "#magnetization chacrateristic at the given asynchronous speed\n", "Im=[0.13,0.37,0.6,0.9,1.2,1.7,2.24,2.9,3.9,4.9,6,8,9,9.5] #magnetization current\n", "E=[12.8,32,53.8,80,106,142,173,200,227,246,260,280,288,292] #back emf\n", "\n", "#calculation\n", "torque=[]\n", "speed=[]\n", "temp=[]\n", "Is=math.sqrt(2/3)*Id #value of stator current for two lead connection\n", "Wms=2*math.pi*N/60\n", "for i in range (1,14,1):\n", " x=(Is**2-Im[i]**2)/(1+2*Xr_*Im[i]/E[i]) #x=Ir_**2\n", " Ir_=math.sqrt(x) #required rotor current\n", " y=(E[i]/Ir_)**2-Xr_**2\n", " S=Rr_/math.sqrt(y) #required slip\n", " N=S*Ns #required speed\n", " T=(3/Wms)*(Ir_)**2*Rr_/S #required torque\n", " speed.append(round(N))\n", " torque.append(round(T,1))\n", " temp.append(round(T,1))\n", "print\"Hence the magnetizatioin curve is\"\n", "print\"Speed :\",speed,\"rpm\"\n", "for i in range(0,13,1):\n", " torque[i]=-1*torque[i]\n", "print\"Braking torque is :\",torque,\"N-m\"\n", "\n", "#results\n", "#plot of of torque vs speed\n", "plt.figure(1)\n", "plt.plot(torque,speed)\n", "plt.xlabel('Torque, N-m') \n", "plt.ylabel('Speed, rpm')\n", "plt.title('Torque vs Speed')\n", "plt.grid(True)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "#plot of Wm vs J/T\n", "inertia_over_torque=[]\n", "for i in range(2,13,1):\n", " J_T=1000*J/temp[i]\n", " inertia_over_torque.append(round(J_T,4))\n", "print\"J/t :\",inertia_over_torque \n", "\n", "Wm=[1,4,8,12,16,20,25,55,95,125,160] \n", "#the values of Wm are taken for the angular frequency with maximum value of Wms=50*pi rad/s\n", "plt.figure(2)\n", "plt.plot(Wm,inertia_over_torque)\n", "plt.xlabel(r'Angular speed $\\omega_m$') \n", "plt.ylabel(' $J/T,1*10^-2$')\n", "plt.title(r'$J/T vs \\omega_m$')\n", "plt.grid(True)\n", "x=[6.5,6.5]\n", "y=[2,4.5]\n", "plt.plot(x,y,'blue')\n", "plt.annotate('A',xy=(8,2), xytext=(8,2.1), arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.annotate('B',xy=(8,4.5), xytext=(8,4.6), arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.annotate('C',xy=(80,3.4), xytext=(80,3.5), arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.annotate('D',xy=(157,8.3), xytext=(157,8.4), arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.annotate('E',xy=(157,2), xytext=(157,2.1), arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.show()\n", "\n", "print\"Hence from the plot the area ABCDEA between the curve and the speed axis for speed change \"\n", "print\"for synchronous to 0.02 times synchrnous speed is the stopping time is which equal to: 9.36 sec\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hence the magnetizatioin curve is\n", "Speed : [2975.0, 949.0, 578.0, 421.0, 306.0, 246.0, 207.0, 174.0, 150.0, 128.0, 86.0, 56.0, 34.0] rpm\n", "Braking torque is : [-2.6, -8.3, -13.5, -18.4, -24.8, -30.0, -34.0, -36.9, -37.5, -35.9, -27.9, -19.5, -12.2] N-m\n" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAEaCAYAAACrcqiAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nJYQQwm1JkRJCCOG2pEgJIYRwW/8PzQ558z2jz0kAAAAASUVORK5CYII=\n", "text": [ "" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "J/t : [7.4074, 5.4348, 4.0323, 3.3333, 2.9412, 2.71, 2.6667, 2.7855, 3.5842, 5.1282, 8.1967]\n" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEfCAYAAABBHLFTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text": [ "" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "Hence from the plot the area ABCDEA between the curve and the speed axis for speed change \n", "for synchronous to 0.02 times synchrnous speed is the stopping time is which equal to: 9.36 sec\n" ] } ], "prompt_number": 8 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.7,Page No:176" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor\n", "f=50 # frequency in HZ\n", "Vl=2200 # line voltage in V\n", "P=6 # number of poles\n", "#parameters referred to the stator\n", "Xr_=0.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=0.12 # resistance of the rotor windings in ohm\n", "Rs=0.075 # resistance of the stator windings in ohm\n", "J=100 # combine inertia of motor and load in kg-m2\n", "\n", "#calculation\n", "#(i) during starting of the motor\n", "Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2) #slip at maximum torque\n", "Wms=4*math.pi*f/P #angular frequency\n", "x=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)\n", "Tmax=(3/2/Wms)*(Vl/math.sqrt(3))**2/x #maximum torque\n", "tm=J*Wms/Tmax #mechanical time constant of the motor\n", "ts=tm*(1/4/Sm+1.5*Sm) #time taken during starting\n", "Es=1/2*J*Wms**2*(1+Rs/Rr_) #energy disspated during starting\n", "\n", "#(ii) when the motor is stopped by plugging method\n", "tb=tm*(0.345*Sm+0.75/Sm) #time required to stop by plugging\n", "Eb=3/2*J*Wms**2*(1+Rs/Rr_) #energy disspated during braking \n", "\n", "#(iii)required resistance to be inserted during plugging\n", "tb1=1.027*tm #minimum value of stopping time during braking\n", "x=1.47*(Xs+Xr_) #x=Rr_+Re\n", "Re=x-Rr_ #Re is the required external resistance to be connected\n", "Ee=3/2*J*Wms**2*(Re/(Re+Rr_)) #energy disspated in the external resistor\n", "Eb1=Eb-Ee #total energy disspated during braking \n", "\n", "\n", "#results\n", "print\"(i)Time taken during starting is ts:\",round(ts,4),\"s\"\n", "print\" Energy disspated during starting is Es:\",round(Es/1000),\"kilo-watt-sec\"\n", "print\"\\n(ii)Time taken to stop by plugging is tb:\",round(tb,2),\"s\"\n", "print\" Energy disspated during braking is Eb:\",round(Eb/1000),\"kilo-watt-sec\"\n", "print\"\\n(iii)Minimum Time taken to stop by plugging is tb:\",round(tb1,2),\"s\"\n", "print\" Required external resistance to be connected is Re:\",round(Re,2),\"ohm\"\n", "print\" Total Energy dissipated during braking is Eb:\",round(Eb1/1000,2),\"kilo-watt-sec\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Time taken during starting is ts: 1.108 s\n", " Energy disspated during starting is Es: 891.0 kilo-watt-sec\n", "\n", "(ii)Time taken to stop by plugging is tb: 3.08 s\n", " Energy disspated during braking is Eb: 2673.0 kilo-watt-sec\n", "\n", "(iii)Minimum Time taken to stop by plugging is tb: 0.5 s\n", " Required external resistance to be connected is Re: 1.35 ohm\n", " Total Energy dissipated during braking is Eb: 1162.36 kilo-watt-sec\n" ] } ], "prompt_number": 206 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.8,Page No:184" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "from sympy import Symbol\n", "from array import array\n", "import numpy as np\n", "\n", "#variable declaration\n", "#ratings of the delta connected Induction motor\n", "f=50 # frequency in HZ\n", "Vl=400 # line voltage in V\n", "P=4 # number of poles\n", "Pm=2.8*1000 # rated mechanical power developed\n", "N=1370 # rated speed in rpm\n", "#parameters referred to the stator\n", "Xr_=5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=5 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "Xm=80 # no load reactance\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "Wms=2*math.pi*Ns/60 #synchronous speed in rad/s\n", "s=(Ns-N)/Ns #full load slip\n", "x=(Rs+Rr_/s)**2+(Xs+Xr_)**2 #total impedance\n", "T=(3/Wms)*(Vl**2*Rr_/s)/x #full load torque\n", "Tl=T\n", "K=Tl/(1-s)**2 #since Tl=K*(1-s)**2\n", "\n", "#(i) when the motor is running at 1200 rpm\n", "N1=1200 #speed in rpm\n", "s1=(Ns-N1)/Ns #slip at the given speed N1\n", "Tl=K*(1-s1)**2 #torque at the given speed N1\n", "\n", "y=(Rs+Rr_/s1)**2+(Xs+Xr_)**2 #total impedance\n", "a=Tl*(Wms/3)*y*(s1/Rr_) #Since T=(3/Wms)*(Vl**2*Rr_/s)/x and a=V**2\n", "V=math.sqrt(a) #required voltage at the given speed N1\n", "Ir_=V/((Rs+Rr_/s1)+1j*(Xs+Xr_))#rotor current\n", "Im=V/(1j*Xm) #magnetizing current\n", "Is=Ir_+Im #total current\n", "Il=abs(Is)*math.sqrt(3) #line current\n", "\n", "#(ii)when the terminal voltage is 300 V\n", "V1=300 #terminal voltage in V\n", "s = Symbol('s')\n", "x=(Rs+Rr_/s)**2+(Xs+Xr_)**2 \n", "T=(3/Wms)*(V1**2*Rr_/s)/x\n", "\n", "#Now we have to solve for the value of slip 's' from the given equation 104s**4- 188s**3 + 89s**2 - 179s + 25=0\"\n", "coeff = [104,-188,89,-179,25] #coeffcient of the polynomial equation \n", "s=np.roots(coeff) #roots of the polynomial equation\n", "\n", "T=K*(1-s[3].real)**2 #torque at the given terminal voltage of 300 V\n", "N=Ns*(1-s[3].real) #speed at the given terminal voltage of 300 V\n", "Ir_=V1/((Rs+Rr_/s[3].real)+1j*(Xs+Xr_))#rotor current\n", "Im=V1/(1j*Xm) #magnetizing current\n", "Is=Ir_+Im #total current\n", "Il1=abs(Is)*math.sqrt(3) #line current\n", "\n", "\n", "#results\n", "print\"(i)Required torque is Tl:\",round(Tl,1),\"N-m\"\n", "print\" Required motor terminal voltage is V:\",round(V,1),\"V\"\n", "print\" Required line current is Il:\",round(Il,2),\"A\"\n", "print\"\\n(ii)The roots of the polynomial equation are \"\n", "print\" s1:\",round(s[0].real,3),\"s2:\",round(s[1].real,3),\"s3:\",round(s[2].real,3),\"s4:\",round(s[3].real,3)\n", "print\" Hence Only s4:\",round(s[3].real,3),\"is valid\"\n", "print\"\\nRequired torque is Tl:\",round(T,2),\"N-m\"\n", "print\"Required speed is N:\",round(N),\"rpm\"\n", "print\"Required line current is Il:\",round(Il1,2),\"A\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Required torque is Tl: 36.9 N-m\n", " Required motor terminal voltage is V: 253.2 V\n", " Required line current is Il: 17.89 A\n", "\n", "(ii)The roots of the polynomial equation are \n", " s1: 1.818 s2: -0.079 s3: -0.079 s4: 0.147\n", " Hence Only s4: 0.147 is valid\n", "\n", "Required torque is Tl: 41.94 N-m\n", "Required speed is N: 1279.0 rpm\n", "Required line current is Il: 16.88 A\n" ] } ], "prompt_number": 4 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.9,Page No:199" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "from array import array\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "#variable declaration\n", "#ratings of the star connected squirrel Induction motor\n", "f=50 # frequency in HZ\n", "Vl=400 # line voltage in V\n", "P=4 # number of poles\n", "N=1370 # rated speed\n", "\n", "#the frequency variation is from 10 Hz to 50 Hz\n", "fmin=10 \n", "fmax=50\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed\n", "N1=Ns-N #increase in speed from no load to full torque rpm\n", "Wms=2*math.pi*Ns/60\n", "s=(Ns-N)/Ns #full load slip\n", "#(i)to obtain the plot between the breakdown torque and the frequency\n", "K=0.1\n", "k=[]\n", "frequency=[]\n", "torque=[]\n", "for i in range (0,9):\n", " K=K+0.1\n", " f1=K*f\n", " x=Rs/K+math.sqrt((Rs/K)**2+(Xs+Xr_)**2)\n", " Tmax=(3/2/Wms)*(Vl/math.sqrt(3))**2/x\n", " k.append(round(K,1))\n", " frequency.append(round(f1))\n", " torque.append(round(Tmax,2))\n", "print\"K :\",k\n", "print\"f :\",frequency,\"Hz\"\n", "print\"Tmax :\",torque,\"N-m\"\n", "\n", "#plotting the values of Tmax vs f \n", "plt.figure(1)\n", "plt.plot(frequency,torque,'y')\n", "plt.xlabel('$f$,Hz')\n", "plt.ylabel('$Tmax$,N-m')\n", "plt.grid(True)\n", "plt.title('Torque vs frequency characteristic')\n", "plt.show()\n", "\n", "#(ii) to obtain the starting torque and current at rated frequency and voltage\n", "x=(Rs+Rr_)**2+(Xs+Xr_)**2\n", "Tst=(3/Wms)*(Vl/math.sqrt(3))**2*Rr_/x #starting torque at 50 Hz frequency\n", "Ist=(Vl/math.sqrt(3))/math.sqrt(x) #starting current at 50 Hz frequency\n", "\n", "K=fmin/fmax #minimum is available at 10 Hz\n", "y=((Rs+Rr_)/K)**2+(Xs+Xr_)**2\n", "Tst_=(3/Wms)*(Vl/math.sqrt(3))**2*Rr_/K/y #starting torque at 10 Hz frequency\n", "Ist_=(Vl/math.sqrt(3))/math.sqrt(y) #starting current at 10 Hz frequency\n", "\n", "ratio1=Tst_/Tst #ratio of starting torque to the rated starting torque\n", "ratio2=Ist_/Ist #ratio of starting current to the rated starting current\n", "\n", "\n", "#results\n", "print\"\\n(i)Hence from the plot we can see that for a constant (V/f) ratio breakdown torque decreases with frequency\"\n", "print\"\\n(ii)Hence the required ratio of starting torque to the rated starting torque is :\",round(ratio1,3)\n", "print\" Hence the required ratio of starting current to the rated starting current is :\",round(ratio2,2)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "K : [0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n", "f : [10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0] Hz\n", "Tmax : [22.93, 31.18, 37.44, 42.22, 45.94, 48.89, 51.27, 53.24, 54.88] N-m\n" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEdCAYAAAAM1BBYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nB9dt23sqOyvAAAAAAElFTkSuQmCC\n", "text": [ "" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "\n", "(i)Hence from the plot we can see that for a constant (V/f) ratio breakdown torque decreases with frequency\n", "\n", "(ii)Hence the required ratio of starting torque to the rated starting torque is : 0.549\n", " Hence the required ratio of starting current to the rated starting current is : 0.33\n" ] } ], "prompt_number": 1 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.10,Page No:201" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "from array import array\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "#variable declaration\n", "#ratings of the star connected squirrel Induction motor is same as that of Ex-6.9\n", "f=50 # frequency in HZ\n", "Vl=400 # line voltage in V\n", "P=4 # number of poles\n", "N=1370 # rated speed\n", "\n", "#the frequency variation is from 5 Hz to 50 Hz\n", "fmin=5 \n", "fmax=50\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed\n", "N1=Ns-N #increase in speed from no load to full torque rpm\n", "Wms=2*math.pi*Ns/60\n", "s=(Ns-N)/Ns #full load slip\n", "Tmax=torque[8] #maximum torque as obtain from Ex-6.9\n", "#to obtain the plot between the voltage and the frequency\n", "K=0\n", "k=[]\n", "frequency=[]\n", "line_voltage=[]\n", "for i in range (0,10):\n", " K=K+0.1\n", " f1=K*f\n", " x=2*K*Wms*Tmax/3\n", " y=Rs+math.sqrt((Rs)**2+(K*(Xs+Xr_))**2)\n", " Vl_square=3*x*y\n", " Vl=math.sqrt(Vl_square)\n", " k.append(round(K,1))\n", " frequency.append(round(f1))\n", " line_voltage.append(round(Vl,1))\n", "print\"K :\",k\n", "print\"f :\",frequency,\"Hz\"\n", "print\"Vl :\",line_voltage,\"V\"\n", "#plotting the values of line voltage Vl vs f \n", "plt.figure(1)\n", "plt.plot(frequency,line_voltage,'b')\n", "plt.xlabel('$f$,Hz')\n", "plt.ylabel('Line voltae,volts')\n", "plt.grid(True)\n", "plt.title('Line voltage vs frequency characteristic')\n", "#for constant V/f ratio\n", "x=[0,10,20,30,40,50]\n", "y=[0,80,160,240,320,400]\n", "plt.plot(x,y,'--')\n", "plt.annotate('Constant V/f ratiuo', xy=(21, 160), xytext=(30, 160),arrowprops=dict(facecolor='black', shrink=0),)\n", "plt.show()\n", "\n", "print\"\\nHence for a constant breakdown torque at all frequencies,\"\n", "print\"V/f ratio has to be progressively increased with increase in frequency\"\n" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "K : [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]\n", "f : [5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0] Hz\n", "Vl : [84.3, 123.8, 159.2, 193.7, 228.0, 262.3, 296.7, 331.1, 365.5, 400.0] V\n" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEdCAYAAADn46tbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nTkSuQmCC\n", "text": [ "" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "\n", "Hence for a constant breakdown torque at all frequencies,\n", "V/f ratio has to be progressively increased with increase in frequency\n" ] } ], "prompt_number": 209 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.11,Page No:202" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the star connected squirrel Induction motor is same as that of Ex-6.9\n", "f=50 # frequency in HZ\n", "Vl=400 # line voltage in V\n", "P=4 # number of poles\n", "N=1370 # rated speed\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed\n", "N1=Ns-N #increase in speed from no load to full torque rpm\n", "Wms=2*math.pi*Ns/60 #synchronous speed\n", "s=(Ns-N)/Ns #full load slip\n", "D=Ns-N #drop in speed from no load to full load torque at 50 Hz\n", "\n", "#(i)when the frequency is 30 Hz and 80% of full load torque\n", "f1=30 #given frequency in Hz\n", "d=D*0.8 #drop in speed from no load to 80% full load torque\n", "Ns1=120*f1/P #synchronous speed at the given frequency f1=30 Hz\n", "N1=Ns1-d #required motor speed \n", "\n", "#(ii)when the speed is 1000 rpm for a full load torque\n", "N2=1000 #given speed in rpm\n", "Ns2=N2+D #synchronous speed\n", "f2=P*Ns2/120 #required frequency\n", "\n", "#when the speed is 1100 rpm and the frequency is 40 Hz\n", "N3=1100 #given speed in rpm\n", "f3=40 #given frequency in Hz\n", "Ns3=120*f3/P #synchronous speed at the given frequency f1=40 Hz\n", "D1=Ns3-N3 #drop in speed from no load to N1=1100 rpm\n", "x=(Rs+Rr_/s)**2+(Xs+Xr_)**2\n", "Tf=(3/Wms)*(Vl/math.sqrt(3))**2*(Rr_/s)/x #full load torque\n", "T1=D1/D*Tf #required torque \n", "\n", "\n", "#results\n", "print\"(i)Hence the required motor speed is :\",round(N1),\"rpm\"\n", "print\"\\n(ii)Hence the required frequency is :\",round(f2,2),\"Hz\"\n", "print\"\\n(iii)Hence the required torque is :\",round(T1,2),\"N-m\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Hence the required motor speed is : 796.0 rpm\n", "\n", "(ii)Hence the required frequency is : 37.67 Hz\n", "\n", "(iii)Hence the required torque is : 19.52 N-m\n" ] } ], "prompt_number": 210 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.12,Page No:204" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor is same as that of Ex-6.9\n", "f=50 # frequency in HZ\n", "Vl=400 #line voltage in V\n", "P=4 # number of poles\n", "N=1370 #rated speed\n", "\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed\n", "N1=Ns-N #increase in speed from no load to full torque rpm\n", "#(i)when f1=30Hz and 80% of full load\n", "Ns=120*f/P\n", "f1=30 #frequency \n", "N2=0.8*N1 #increase in speed from no load to 80% of full torque rpm\n", "Ns1=f1/f*Ns\n", "N=Ns1+N2 #machine speed\n", "\n", "#(ii)at a speed of 1000rpm\n", "N2=1000 #given speed in rpm\n", "N3=N2-N1 #synchronous speed\n", "f3=P*N3/120 #required frequency\n", "\n", "#(iii)when frequency is 40Hz and speed is 1300 rpm\n", "f4=40 #frequency in hz\n", "N2=1300 #speed in rpm\n", "Ns=120*f4/P #required synchronous speed in rpm\n", "N4=N2-Ns #increase in speed from no load speed in rpm\n", "Tf=25.37 #full load torque as calculated in Ex-6.11\n", "Tm=-N4/N1*Tf #motor torque\n", "\n", "#(iv) when the motor is under dynamic braking\n", "\n", "\n", "#results\n", "print\"(i)Required speed is :\",N,\"rpm\"\n", "print\"\\n(ii)required frequency is:\",f3,\"Hz\"\n", "print\"\\n(iii)Required motor torque :\",round(Tm,2),\"N-m\"\n", "print\"\\n(iv)The value of the frequency,speed and motor torque calculated in (i),(ii) and(iii)\"\n", "print\" will be the same when the motor is operated under dynamic braking\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Required speed is : 1004.0 rpm\n", "\n", "(ii)required frequency is: 29.0 Hz\n", "\n", "(iii)Required motor torque : -19.52 N-m\n", "\n", "(iv)The value of the frequency,speed and motor torque calculated in (i),(ii) and(iii)\n", " will be the same when the motor is operated under dynamic braking\n" ] } ], "prompt_number": 211 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.13,Page No:204" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor is same as that of Ex-6.9\n", "f=50 # frequency in HZ\n", "Vl=400 #line voltage in V\n", "P=4 # number of poles\n", "N=1370 #rated speed\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "\n", "#calculation\n", "Wms=4*math.pi*f/P\n", "f1=60 #frequency in Hz during speed control of the motor\n", "K=f1/f #the value of K at 60Hz \n", "x=Rs+math.sqrt(Rs**2+K**2*(Xs+Xr_)**2)\n", "Tmax_=3/(2*K*Wms)*(Vl/math.sqrt(3))**2/x #torque at 60 Hz frequency\n", "z=Rs+math.sqrt(Rs**2+(Xs+Xr_)**2)\n", "Tmax=3/(2*Wms)*(Vl/math.sqrt(3))**2/z #maximum torque\n", "ratio=Tmax_/Tmax #ratio\n", "\n", "#results\n", "print\"Ratio of Motor breakdown torque at 60Hz to rated torque at 50Hz is:\",round(ratio,3)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Ratio of Motor breakdown torque at 60Hz to rated torque at 50Hz is: 0.727\n" ] } ], "prompt_number": 212 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.14,Page No:209" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "print\"When operating at a frequency K times rated frequency f then\"\n", "print\"Im**2=[((Rr_/Ksf)**2+(2*pi*Lr_)**2)/((Rr_/Ksf)**2+(2*pi*Lm+2*Pi*Lr_)**2)]*Is**2----(1)\"\n", "print\"Since Im is constant for constant flux therefore\"\n", "print\"K*s*f=constant--------(2)\"\n", "print\"K*Wms*s=constant-------(3) which is the slip speed\"\n", "print\"s*K=constant----------(4)\"\n", "print\"Thereofre for a frequency K*f\"\n", "print\"T=(3/K/Wms)*[(Is*K*Xm)**2*(Rr_/s)/((Rr_/s)**2+K**2*(Xm+Xr_)**2]\"\n", "print\"T=(3/K/Wms*s)*[(Is*Xm)**2*(Rr_)/((Rr_/s/K)**2+(Xm+Xr_)**2]-------(5)\"\n", "print\"\\nHence for a given slip speed (K*Wms*s),K*s is constant and from (1) for a given K*s*f and constant flux\"\n", "print\"operation Is is fixed. Now from (5) T is also fixed. Thus, motor develps a constant torque and draws a\"\n", "print\"constant current from the inverter at all frequencies for a given slip speed\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "When operating at a frequency K times rated frequency f then\n", "Im**2=[((Rr_/Ksf)**2+(2*pi*Lr_)**2)/((Rr_/Ksf)**2+(2*pi*Lm+2*Pi*Lr_)**2)]*Is**2----(1)\n", "Since Im is constant for constant flux therefore\n", "K*s*f=constant--------(2)\n", "K*Wms*s=constant-------(3) which is the slip speed\n", "s*K=constant----------(4)\n", "Thereofre for a frequency K*f\n", "T=(3/K/Wms)*[(Is*K*Xm)**2*(Rr_/s)/((Rr_/s)**2+K**2*(Xm+Xr_)**2]\n", "T=(3/K/Wms*s)*[(Is*Xm)**2*(Rr_)/((Rr_/s/K)**2+(Xm+Xr_)**2]-------(5)\n", "\n", "Hence for a given slip speed (K*Wms*s),K*s is constant and from (1) for a given K*s*f and constant flux\n", "operation Is is fixed. Now from (5) T is also fixed. Thus, motor develps a constant torque and draws a\n", "constant current from the inverter at all frequencies for a given slip speed\n" ] } ], "prompt_number": 213 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.15,Page No:210" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor \n", "f=50 # frequency in HZ\n", "Vl=400 #line voltage in V\n", "P=4 # number of poles\n", "N=1370 #rated speed\n", "#parameters referred to the stator\n", "Xr_=3.5 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=3 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "Xm=55 # magnetizing reactance in ohm\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed in rpm\n", "s=(Ns-N)/Ns #full load slip\n", "x=1j*Xm*(Rr_/s+1j*Xr_)\n", "y=Rr_/s+1j*(Xr_+Xm)\n", "Z=Rs+1j*Xs+x/y #total motor impedance\n", "Isf=(Vl/math.sqrt(3))/abs(Z) #full load stator current\n", "Irf_=Isf*(1j*Xm)/(Rr_/s+1j*(Xr_+Xm)) #full load rotor current\n", "Tf=(3/Wms)*abs(Irf_)**2*Rr_/s #full load torque\n", "N1=Ns-N #full load slip speed\n", "#(i) when the motor is operating at 30Hz\n", "f1=30 #given frequency in Hz\n", "#at rated slep speedvalue of torque and stator current is same as the rated value\n", "T=Tf \n", "Is=abs(Isf) \n", "Ns1=f1/f*Ns #synchronous at f1=30Hz\n", "N2=Ns1-N1 #required motor speed at 30Hz\n", "\n", "#(ii)at a speed of 1200 rpm\n", "N3=1200 #speed in rpm\n", "Ns1=N3+N1 #required synchronous speed\n", "f1=Ns1/Ns*f #required frequency at N2=1200rpm\n", "\n", "#(iii)when speed-torque curves are assumed to be straight lines at 30Hz at half the rated motor torque\n", "f2=30 #frequency in Hz\n", "N1_=N1/2 #slip at half the rated torque\n", "Ns1=f2/f*Ns #synchronous at f1=30Hz\n", "N4=Ns1-N1_ #required motor speed\n", "\n", "#(iv) When the motor is operating at 45hz and braking torque is equal to rated torque\n", "f3=45 #given frequency in Hz\n", "N1_=-N1 #slip speed when braking at rated torque\n", "Ns1=f3/f*Ns #synchronous at f1=45Hz\n", "N5=Ns1-N1_ #required motor speed\n", "\n", "\n", "#results\n", "print\"(i)At 30Hz the required value of Torque is T:\",round(T,2),\"N-m \"\n", "print\" Stator current is Is:\",round(Is,4),\"A\"\n", "print\" Motor speed is :\",N2,\"rpm\"\n", "print\"\\n(ii)Required inverter frequency is :\",round(f1,2),\"Hz\"\n", "print\"\\n(iii)Required motor speed at 30Hz is:\",N4,\"rpm\"\n", "print\"\\n(iv)Required motor speed at 45Hz is:\",N5,\"rpm\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)At 30Hz the required value of Torque is T: 22.71 N-m \n", " Stator current is Is: 7.2442 A\n", " Motor speed is : 770.0 rpm\n", "\n", "(ii)Required inverter frequency is : 44.33 Hz\n", "\n", "(iii)Required motor speed at 30Hz is: 835.0 rpm\n", "\n", "(iv)Required motor speed at 45Hz is: 1480.0 rpm\n" ] } ], "prompt_number": 214 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.16,Page No:215" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "import cmath\n", "from __future__ import division\n", "\n", "#variable declaration\n", "#ratings of the Delta connected slipring Induction motor\n", "f=50 # frequency in HZ\n", "Vl=400 #line voltage in V\n", "P=6 # number of poles\n", "SR=2.2 #ratio of stator to rotor\n", "#parameters referred to the stator\n", "Xr_=1 # rotor winding reactance in ohm \n", "Rr_=0.2 # resistance of the rotor windings in ohm\n", "s=0.04 # given slip when motor runs at full load\n", "\n", "#calculation\n", "Ns=120*f/P #synchronous speed\n", "Wms=2*math.pi*Ns/60\n", "x=(Rr_/s)**2+Xr_**2\n", "Tf=(3/Wms)*(Vl)**2*(Rr_/s)/x #full load torque\n", "K=Tf/(Ns*(1-s))**2\n", "N=850 #speed of the motor in rpm\n", "Tl=K*N**2 #torque at the given speed N\n", "s=(Ns-N)/Ns #slip at the given speed N\n", "y=Tl*(Wms/3)/Vl**2 #y=X/(X**2+Xr_**2) and X=(Re+Rr_)/s\n", "print\"The torque at the given speed of 850rpm is:\",round(Tl),\"N-m\"\n", "print\"With a slip of s:\",s\n", "print\"To find the external resistance connected the given quadratic equation is X**2-6.633X+1=0\"\n", "print\"With X=(Re-Rr_)/s where Re is the required external resistance\" \n", "a = 1\n", "b = -1/y\n", "c = 1\n", "# calculate the discriminant\n", "d = (b**2) - (4*a*c)\n", "# find two solutions\n", "X1 = (-b-cmath.sqrt(d))/(2*a)\n", "X2 = (-b+cmath.sqrt(d))/(2*a)\n", "\n", "#results\n", "print\"The solution for X are \",round(X1.real,4),\"and\",round(X2.real,4)\n", "Re1=X1*s-Rr_\n", "Re2=X2*s-Rr_\n", "\n", "if (Re1.real>0) :\n", " print\"\\nThe number Re1:\",round(abs(Re1),3),\"ohm is feasible:\"\n", " R=Re1.real/SR**2\n", " print\"Rotor referred value of the external resistance is:\",round(R,3),\"ohm\"\n", "\n", "if (Re2.real>0) :\n", " print\"\\nThen Re2:\",round(abs(Re2),3),\"ohm is feasible\" \n", " R=Re2.real/SR**2\n", " print\"Hence Rotor referred value of the external resistance is:\",round(R,3),\"ohm\" " ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "The torque at the given speed of 850rpm is: 691.0 N-m\n", "With a slip of s: 0.15\n", "To find the external resistance connected the given quadratic equation is X**2-6.633X+1=0\n", "With X=(Re-Rr_)/s where Re is the required external resistance\n", "The solution for X are 0.1544 and 6.4786\n", "\n", "Then Re2: 0.772 ohm is feasible\n", "Hence Rotor referred value of the external resistance is: 0.159 ohm\n" ] } ], "prompt_number": 217 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.17,Page No:217" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "from sympy import Symbol\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor \n", "f=50 # frequency in HZ\n", "Vl=440 #line voltage in V\n", "P=6 # number of poles\n", "Ns=120*f/P #synchronous speed\n", "#parameters referred to the stator\n", "Xr_=1.2 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=0.4 # resistance of the rotor windings in ohm\n", "Rs=0.5 # resistance of the stator windings in ohm\n", "Xm=50 # magnetizing reatance\n", "a=3.5 # stator to rotor turns ratio\n", "delta=0 # duty ratio at the given breakdown torque\n", "Sm=1 # slip at standstill\n", "#calculation\n", "#slip at maximum torque without an external resistance is Sm=Rr_/math.sqrt(Rs**2+(Xs+Xr_)**2) \n", "#when an external resistanc Re referred to the stator is connected \n", "x=Sm*math.sqrt(Rs**2+(Xs+Xr_)**2) #x=Re+Rr_\n", "Re=x-Rr_\n", "y=0.5*a**2*(1-delta) # y=0.5*a**2*R*(1-delta) #y=Re\n", "R=Re/y\n", "\n", "N = Symbol('N')\n", "Sm=(Ns-N)/Ns\n", "c=(x*Sm-Rr_)/(0.5*a**2*R) #c=(1-delta)\n", "delta=1-c #given duty ratio\n", "\n", "#results\n", "print\"variation of the duty ratio is\",round(delta*1000/N,3),\"*N*10**(-3)\"\n", "print\"Hence the duty ratio must change linearly with speed N\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "variation of the duty ratio is 1.195 *N*10**(-3)\n", "Hence the duty ratio must change linearly with speed N\n" ] } ], "prompt_number": 7 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.18,Page No:223" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor \n", "f=50 # frequency in HZ\n", "Vl=440 # line voltage in V\n", "P=6 # number of poles\n", "N=970 # rated speed\n", "n=2 # ratio of stator to rotor\n", "Sm=0.25 # it is given the speed range is 25% below the synchronous speed which is proportional to the Slip\n", "#parameters referred to the stator\n", "Xr_=0.4 # rotor winding reactance in ohm\n", "Xs=0.3 # stator winding reactance in ohm\n", "Rr_=0.08 # resistance of the rotor windings in ohm\n", "Rs=0.1 # resistance of the stator windings in ohm\n", "alpha=165 # maximum value of the firing angle in degress\n", "\n", "#calculation\n", "Ns=120*f/P # synchronous speed\n", "Wms=2*math.pi*Ns/60\n", "#(i) transformer turns ratio\n", "a=-Sm/math.cos(math.radians(alpha)) #since Sm=a*math.cos(alpha) \n", "m=n/a #since a=n/m where m is the transformer ratio\n", "\n", "#(ii)When speed is 780 rpm and firing angle is 140 degrees\n", "N1=780 #given speed\n", "alpha1=140 #given firing angle\n", "s1=(Ns-N1)/Ns #slip at the given speed N1\n", "Vd1=(3*math.sqrt(6)/math.pi)*s1*(Vl/math.sqrt(3))/n\n", "Vd2=(3*math.sqrt(6)/math.pi)*(Vl/math.sqrt(3))/m*math.cos(math.radians(alpha1))\n", "Rs_=Rs*(1/n)**2 #stator resistance referred to the rotor\n", "Rr=Rr_*(1/n)**2 #rotor resistance referred to the rotor\n", "Rd=0.01 #equivalent resistance of the DC link inductor\n", "Id=(Vd1+Vd2)/(2*(s1*Rs_+Rr)+Rd)\n", "T1=abs(Vd2)*Id/s1/Wms #required torque\n", "\n", "#(iii)when speed is 800rpm and firing angle is half the rated motor torque\n", "N1=800 #given speed\n", "s=(Ns-N)/Ns #rated slip\n", "x=(Rs+Rr_/s)**2+(Xs+Xr_)**2\n", "Trated=(3/Wms)*(Vl/math.sqrt(3))**2*(Rr_/s)/x #rated torque\n", "T_half=Trated/2 #half rated torque\n", "s1=(Ns-N1)/Ns #given slip at speed N1=800rpm\n", "Vd1=(3*math.sqrt(6)/math.pi)*s1*(Vl/math.sqrt(3))/n\n", "cos_alpha1 = Symbol('cos_alpha1')\n", "Vd2=(3*math.sqrt(6)/math.pi)*(Vl/math.sqrt(3))/m*cos_alpha1\n", "Id=(Vd1+Vd2)/(2*(s1*Rs_+Rr)+Rd)\n", "T=abs(Vd2)*Id/s1/Wms #required torque\n", "#let cos_alpha1=-X\n", "X=-cos_alpha1\n", "#since the given torque is half of the rated value\n", "#To find the find the firing angle we assumed cos(alpha1)=-X\n", "#The given quadratic equation is X**2-0.772X+0.06425=0\n", "a = 1\n", "b = -0.772\n", "c = 0.06425\n", "# calculate the discriminant\n", "d = (b**2) - (4*a*c)\n", "# find two solutions\n", "X1 = (-b-cmath.sqrt(d))/(2*a)\n", "X2 = (-b+cmath.sqrt(d))/(2*a)\n", "alpha1=-math.acos(X2.real) #since cos(alpha1)=-X where alpha1 is radians\n", "alpha1=math.degrees(alpha1) #angle in degrees\n", "alpha1=180+alpha1 #required firing angle\n", "\n", "\n", "#results\n", "print\"(i)Transformer ratio is: \",round(m,3)\n", "print\"\\n(ii)Required torque is :\",round(T1),\"N-m\"\n", "print\" There is a slight difference in the answer for the torque due to accuracy i.e more number of decimal place\"\n", "print\"\\n(iii)The half rated torque at the given speed of\",N1,\"rpm is:\",round(T_half,2),\"N-m\"\n", "print\" With a slip of s:\",s1\n", "print\"The solution for X are \",round(X1.real,4),\"and\",round(X2.real,4)\n", "print\"For X1:\",round(X1.real,4),\" the motor is unstable hence we discard this value and we use X2:\",round(X2.real,4)\n", "print\"\\nHence the required firing angle is :\",round(alpha1,1),\"\u00b0\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)Transformer ratio is: 7.727\n", "\n", "(ii)Required torque is : 271.0 N-m\n", " There is a slight difference in the answer for the torque due to accuracy i.e more number of decimal place\n", "\n", "(iii)The half rated torque at the given speed of 800 rpm is: 302.66 N-m\n", " With a slip of s: 0.2\n", "The solution for X are 0.0949 and 0.6771\n", "For X1: 0.0949 the motor is unstable hence we discard this value and we use X2: 0.6771\n", "\n", "Hence the required firing angle is : 132.6 \u00b0\n" ] } ], "prompt_number": 219 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.19,Page No:225" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the star connected Induction motor is same as that of Ex-6.17\n", "f=50 # frequency in HZ\n", "Vs=440 # line voltage in V\n", "P=4 # number of poles\n", "#parameters referred to the stator\n", "Xr_=1.2 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=0.4 # resistance of the rotor windings in ohm\n", "Rs=0.5 # resistance of the stator windings in ohm\n", "Xm=50 # magnetizing reatance\n", "a=3.5 # stator to rotor turns ratio\n", "\n", "#calculation\n", "Ns=120*f/P # synchronous speed in rpm\n", "Wms=2*math.pi*Ns/60 # synchronous speed in rad/s\n", "#(i)when motor speed is 1200rpm with a voltage of 15+0j V\n", "V=cmath.rect(15,0)\n", "N1=1200 #speed in rpm\n", "Vr_=a*V #rotor voltage\n", "s1=(Ns-N1)/Ns #slip at the given speed N1=1200 rpm\n", "Z=Rs+Rr_/s1+1j*(Xs+Xr_) #total impedance\n", "Ir_=(Vs/math.sqrt(3)-Vr_/s1)/Z #rotor current\n", "phi_r=cmath.phase(Vr_)-cmath.phase(Ir_) #angle between Vr_ and Ir_\n", "Pr=3*(abs(Ir_))**2*Rr_ #rotor copper loss\n", "P1=3*abs(Vr_)*abs(Ir_)*math.cos(phi_r) #power absorbed by Vr_\n", "Pg=(Pr+P1)/s1 #gross power \n", "T=Pg/Wms #required motor torque\n", "\n", "#(ii)when motor speed is 1200rpm with a unity power factor \n", "N1=1200 #speed in rpm\n", "Ir_=cmath.rect(abs(Ir_),0) #machine is operating at unity power factor\n", "x=Ir_*Z #x=(Vs-Vr_/s1)*phi_r where phi_r is the angle between Vr_ and Ir_\n", "\n", "#x=a+b\n", "d=(Vs/math.sqrt(3)-Vr_/s1*math.cos(phi_r))**2\n", "e=(Vr_/s1*math.sin(phi_r))**2\n", "f=x/(d+e)\n", "theta=cmath.phase(f) #required angle in radian\n", "\n", "#Now we should solve for the quadratice equation for the rotor current\n", "# 0.9*Ir_**2 + 50.8*Ir_ + 90.12 = 0\n", "a1 = 0.9\n", "b1 = 50.8\n", "c1 = 90.12\n", "# calculate the discriminant\n", "d = (b1**2) - (4*a1*c1)\n", "# find two solutions\n", "Ir_1 = (-b1-cmath.sqrt(d))/(2*a1)\n", "Ir_2 = (-b1+cmath.sqrt(d))/(2*a1)\n", "\n", "Ir_=Ir_2 #Ir_2 is chosen because for Ir_1 the motor is unstable\n", "Vr_sin_phi_r=abs(Ir_)/2.083\n", "Vr_cos_phi_r=s1*(Vs/math.sqrt(3)+2.5*Vr_sin_phi_r)\n", "Vr_=Vr_cos_phi_r+1j*Vr_sin_phi_r #total rotor voltage referred to the stator\n", "Vr_=Vr_/a #total rotor voltage referred to the rotor\n", "phase=round(math.degrees(cmath.phase(Vr_))) #required phase of the voltage in degrees\n", "\n", "#results\n", "print\"(i)The torque is :\",round(T,2),\"N-m and since it is negative the motor is operating in regenerative braking \"\n", "print\"\\n(ii)Now theta \u03b8:\",round(math.degrees(theta),2),\"\u25e6\"\n", "print\" The solution for Ir_ are \",round(Ir_1.real,3),\"and\",round(Ir_2.real,3)\n", "print\" We choose Ir_:\",round(Ir_2.real,3),\"A since higher value corresponds to unstable region\"\n", "print\"\\n Hence the required voltage magnitude is Vr:\",round(abs(Vr_),2),\"V\",\";phase:\",phase,\"\u25e6\"\n", "print\"\\n Note :There is a slight difference in the answers due to accuracy i.e more number of decimal place\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(i)The torque is : -8.61 N-m and since it is negative the motor is operating in regenerative braking \n", "\n", "(ii)Now theta \u03b8: 43.83 \u25e6\n", " The solution for Ir_ are -54.611 and -1.834\n", " We choose Ir_: -1.834 A since higher value corresponds to unstable region\n", "\n", " Hence the required voltage magnitude is Vr: 14.64 V ;phase: 1.0 \u25e6\n", "\n", " Note :There is a slight difference in the answers due to accuracy i.e more number of decimal place\n" ] } ], "prompt_number": 220 }, { "cell_type": "heading", "level": 2, "metadata": {}, "source": [ "Example No:6.20,Page No:234" ] }, { "cell_type": "code", "collapsed": false, "input": [ "import math\n", "from __future__ import division\n", "import cmath\n", "\n", "#variable declaration\n", "#ratings of the single phase Induction motor \n", "f=50 # frequency in HZ\n", "Vs=220 # supply voltage in V\n", "P=4 # number of poles\n", "N=1425 # rated speed in rpm\n", "#parameters referred to the stator\n", "Xr_=6 # rotor winding reactance in ohm\n", "Xs=Xr_ # stator winding reactance in ohm\n", "Rr_=5 # resistance of the rotor windings in ohm\n", "Rs=2 # resistance of the stator windings in ohm\n", "Xm=60 # magnetizing reatance\n", "\n", "#calculation\n", "N1=1200 #when the motor is operating at the given speed in rpm\n", "Ns=120*f/P # synchronous speed\n", "Wms=2*math.pi*Ns/60\n", "s=(Ns-N)/Ns #rated slip\n", "\n", "Zf=1j*(Xm)*(Rr_/s+1j*Xr_)/2/(Rr_/s+1j*(Xr_+Xm))\n", "Rf=Zf.real ; Xf=Zf.imag\n", "Zb=1j*(Xm)*(Rr_/(2-s)+1j*Xr_)/2/(Rr_/(2-s)+1j*(Xr_+Xm))\n", "Rb=Zb.real ; Xb=Zb.imag\n", "Zs=Rs+1j*Xs\n", "Z=Zs+Zf+Zb\n", "Is=(Vs)/Z\n", "T=(abs(Is))**2/Wms*(Rf-Rb)\n", "Tl=T\n", "K=Tl/N**2\n", "\n", "#therefore for a speed of of N1=1200 rpm we get \n", "Tl=K*N1**2 #required load torque for the given speed N1\n", "s1=(Ns-N1)/Ns # slip for the given speed N1\n", "\n", "Zf=1j*(Xm)*(Rr_/s1+1j*Xr_)/2/(Rr_/s1+1j*(Xm))\n", "Rf=Zf.real ; Xf=Zf.imag\n", "Zb=1j*(Xm)*(Rr_/(2-s1)+1j*Xr_)/2/(Rr_/(2-s1)+1j*(Xr_+Xm))\n", "Rb=Zb.real ; Xb=Zb.imag\n", "x=(Wms*Tl)/(Rf-Rb) #since Tl=(abs(Is))**2/Wms*(Rf-Rb) and x=Is**2\n", "Is=math.sqrt(x)\n", "Z=Zs+Zf+Zb\n", "V=Is*abs(Z)\n", "\n", "#results\n", "print\"Hence the motor terminal voltage at the speed of\",N1,\"rpm is : \",round(V,1),\"V\"" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "Hence the motor terminal voltage at the speed of 1200 rpm is : 127.9 V\n" ] } ], "prompt_number": 221 } ], "metadata": {} } ] }