{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# CHAPTER 44 : INDUSTRIAL APPLICATIONS OF ELECTRIC MOTORS "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.1 , PAGE NO :- 1769"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Total annual cost in group drive = RS. 11000.0\n",
"Total annual cost in individual drive = RS. 11400.0\n",
"Hence,Individual drive is costlier than group drive.\n"
]
}
],
"source": [
"'''A motor costing Rs. 10,000 is used for group drive in a certain installation.How will its total annual cost compare with\n",
"the case where four individuals motors each costing Rs. 4000 were used? With group drive,the energy consumption is\n",
"50MWh whereas it is 45MWh for individual drive.The cost of electric energy is 20 paise/kWh.Assume depriciation,\n",
"maintenance and other fixed charges at 10% in the case of group drive and 15 percent in the case of individual drive.'''\n",
"\n",
"\n",
"#Group drive\n",
"cost_g = 10000.0 #Rs (Capital cost)\n",
"other_g = 0.1*cost_g #Rs (Annual depriciation,maintenance and other charges)\n",
"enrgy_g = 50.0*1000*20/100.0 #Rs (Annual cost of energy)\n",
"total_g = enrgy_g + other_g #Rs (total annual cost)\n",
"\n",
"#Individual drive\n",
"cost_i = 4*4000.0 #Rs (Capital cost)\n",
"other_i = 0.15*cost_i #Rs (Annual depriciation,maintenance and other charges)\n",
"enrgy_i = 45.0*1000*20/100.0 #Rs (Annual cost of energy)\n",
"total_i = enrgy_i + other_i #Rs (total annual cost)\n",
"print \"Total annual cost in group drive = RS.\",total_g\n",
"print \"Total annual cost in individual drive = RS.\",total_i\n",
"print \"Hence,Individual drive is costlier than group drive.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.2 , PAGE NO :- 1775 "
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Additional resistance = 5.7 ohm.\n",
"Initial braking Torque = 955.41 N-m.\n",
"Torque at 360 rpm = 766.53 N-m.\n"
]
}
],
"source": [
"'''A 40-kW,440-V,d.c shunt motor is braked by plugging.Calculate(i)the value of resistance that must be placed in series with the\n",
"armature circuit to limit the initial braking current to 150A (ii)the braking torque and(iii)the torque when motor speed falls\n",
"to 360 rpm. Armature resistance Ra = 0.1 ohm,ful-load Ia=100A,full-load speed=600 rpm.'''\n",
"\n",
"V = 440.0 #V (applied voltage)\n",
"Ib = 150.0 #A (initial braking current)\n",
"Ra = 0.1 #ohm (armature resistance)\n",
"Ia = 100.0 #A (armature current)\n",
"N1 = 600.0 #rpm (full load speed)\n",
"N2 = 360.0 #rpm (decreased speed)\n",
"Eb = V - Ia*Ra #V (back emf)\n",
"#Voltage across the armature at the start of braking\n",
"V2 = V + Eb #V\n",
"#(i)Since initial braking current is limited to 150A,total armature circuit resistance required is\n",
"Rt = V2/Ib #ohm\n",
"#Therefore additional resistance R is\n",
"R = Rt - Ra #ohm\n",
"#(ii)For a shunt motor,Torque(Tb) is propotional to Ia\n",
"Tb = 40*1000/(2*3.14*600/60) #N/m\n",
"# .'. Initial braking torque/full-load torque = initial braking current/full-load current\n",
"\n",
"T_ini = Tb*(Ib/Ia) #N/m\n",
"#(iii)The decrease in Eb is directly propotional to decrease in motor speed\n",
"Eb_360 = Eb*(N2/N1) #V\n",
"Ia_360 = (V+Eb_360)/Rt #A\n",
"Tb_360 = Tb*(Ia_360/Ia) #N-m\n",
"\n",
"print \"Additional resistance = \",R,\"ohm.\"\n",
"print \"Initial braking Torque = \",round(T_ini,2),\"N-m.\"\n",
"print \"Torque at 360 rpm = \",round(Tb_360,2),\"N-m.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.3 , PAGE NO :- 1776"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Plugging torque = 131.92 N-m.\n"
]
}
],
"source": [
"'''A 30-kW,400-V,3-phase,4 pole,50-Hz induction motor has full-load slip of 5%.If the ratio of standstill reactance to resistance\n",
"per motor phase is 4 ,estimating the plugging torque at full speed.'''\n",
"\n",
"Power = 30.0 #kW (power consumed)\n",
"f = 50.0 #Hz (frequency)\n",
"P = 4 # (pole)\n",
"s1 = 0.05 # (slip)\n",
"Ns = 120*f/P #rpm (Synchronus speed)\n",
"Nf = Ns*(1-s1) #rpm (Full-load speed)\n",
"Tf = Power*1000/(2*3.14*Nf/60) #N-m (Full-load torque)\n",
"R1_X1 = 4.0 \n",
"\n",
"# As T is propotional to (s*R2*E2^2)/(R2^2 + s^2*X2^2) i.e (T2/T1) = (s2/s1)*(1+s1^2(X2/R2)^2/1+s2^2(X2/R2)^2)\n",
"s2 = 2-s1\n",
"Tp = (s2/s1)*(1 +(R1_X1)*(R1_X1)*s1*s1)/(1 +(R1_X1)*(R1_X1)*s2*s2)*Tf\n",
"print \"Plugging torque = \",round(Tp,2),\"N-m.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.4 , PAGE NO :- 1780"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hence,energy returned to supply lines = 43.43 kWh.\n"
]
}
],
"source": [
"'''A 500 tonne electric trains travel down a descending gradient of 1 in 80 for 90 seconds during which period its speed is\n",
"reduced from 100 km/h to 60 km/h by regenerative braking.Compute the energy returned to the lines of kWh if tractive\n",
"resistance = 50N/t;allowance for rotational inertia = 10%;overall efficiency of the system = 75%.'''\n",
"\n",
"\n",
"G = 1/80.0*100 # (percent gradient)\n",
"M = 500.0 #tonne (electric train)\n",
"Me_M = 1.1 # (ratio of rotational mass to stationary mass)\n",
"V1 = 100.0 #km/h (initial speed)\n",
"V2 = 60.0 #km/h (decreased speed)\n",
"t = 90.0 #s (braking period)\n",
"r = 50.0 #N/t (tractive resistance)\n",
"eff = 0.75 # (efficiency)\n",
"d = (V1+V2)/2*t/3600\n",
"#Hence,energy returned to supply line is\n",
"enrgy = 0.75*(0.01072*(Me_M)*(V1*V1 - V2*V2) + d*(27.25*G - 0.2778*r)) #Wh/tonne\n",
"enrgy = enrgy*500/1000.0 #kWh\n",
"print \"Hence,energy returned to supply lines =\",round(enrgy,2),\"kWh.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.5 , PAGE NO :- 1780"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Power returned to line = 509.0 kW.\n"
]
}
],
"source": [
"'''A 350-t electric train has its speed reduced by regenerative braking from 60 to 40km/h over a distance of 2km along down gradient\n",
"of 1.5%.Calculate (i)electrical energy and (ii)average power returned to the line.Assume specific train resistance = 50 N/t;rotational\n",
"inertia effect = 10% ; conversion efficency of the system = 75%.'''\n",
"\n",
"\n",
"M = 350.0 #tonne (Mass of train)\n",
"eff = 0.75 # (efficiency)\n",
"V1 = 60.0 #km/h (initial speed)\n",
"V2 = 40.0 #km/h (final speed)\n",
"Me = 1.1*M # (rotational mass )\n",
"G = 1.5 # (percent gradient)\n",
"d = 2.0 #km (distance)\n",
"r = 50.0 #N/t (train resistance)\n",
"\n",
"#Energy returned to line is\n",
"enrgy = eff*(0.01072*Me/M*(V1*V1 - V2*V2) + d*(27.25*G - 0.2778*r)) #Wh/t\n",
"enrgy = enrgy*M/1000 #kWh\n",
"\n",
"#(ii)\n",
"\n",
"speed = (V1+V2)/2 #km/h (Average speed)\n",
"time = d/speed #h (time taken)\n",
"\n",
"power = enrgy/time #kW (power returned)\n",
"\n",
"print \"Power returned to line =\",round(power),\"kW.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.6 , PAGE NO :- 1780"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Power fed to line = 424.38 kW.\n"
]
}
],
"source": [
"'''If in Example 44.5,regenerative braking is applied in such a way that train speed on down gradient remains constant\n",
"at 60 km/h,what would be the power fed into the line?'''\n",
"\n",
"\n",
"M = 350.0 #tonne (Mass of train)\n",
"G = 1.5 # (percent gradient)\n",
"r = 50.0 #N/t (train resistance)\n",
"V = 60.0 #km/h (speed)\n",
"eff = 0.75\n",
"#In down-gradient motors act as generators .Force generated\n",
"Ft = 98*M*G - M*r #N\n",
"#Power that can be recuperated is\n",
"P = Ft*(1000.0/3600)*V #W\n",
"#Power actually sent to line\n",
"P = eff*P/1000 #kW\n",
"print \"Power fed to line = \",round(P,2),\"kW.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.7 , PAGE NO :- 1780 "
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Power fed = 650.0 kW.\n"
]
}
],
"source": [
"'''A train weighing 500 tonne is going down a gradient of 20 in 1000.It is desired to maintain train speed at 40 km/h by regenerative\n",
"braking.Calculate the power fed into the line.Tractive resistance is 40 N/t and allow rotational inertia of 10% and efficiency\n",
"of conversion of 75%.'''\n",
"\n",
"M = 500.0 #tonne (Mass of train)\n",
"G = 20/1000.0*100 # (percent gradient)\n",
"r = 40.0 #N/t (Tractive resistance)\n",
"V = 40.0 #km/h (speed)\n",
"eff = 0.75 # (efficiency) \n",
"#Tractive Force when motors are driven as generators is\n",
"Ft = 98*M*G - M*r #N\n",
"#Power that can be drawn is\n",
"P = 0.2778*Ft*V #W\n",
"#Power actually fed\n",
"P = eff*P/1000 #kW\n",
"print \"Power fed = \",round(P,0),\"kW.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.8 , PAGE NO :- 1781"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Additional resistance = 1.94 ohm.\n",
"Initial braking torque = 1042.27 N-m.\n",
"Braking torque at 200rpm = 719.84 N-m.\n"
]
}
],
"source": [
"'''A 250V d.c shunt motor,taking an armature current of 150 A and running at 550 r.p.m is braked by reversing the connections to the\n",
"armature and inserting additional resistance in series with it.Calculate:\n",
"(a)the value of series resistance required to limit the initial current to 240A.\n",
"(b)the initial value of braking torque.\n",
"(c)the value of braking torque when the speed has fallen to 200 r.p.m.\n",
"The armature resistance is 0.09 ohm.Neglect winding friction and iron losses.'''\n",
"\n",
"V = 250.0 #V (applied voltage)\n",
"Ia = 150.0 #A (armature current)\n",
"Ib = 240.0 #A (initial braking current)\n",
"N = 550.0 #rpm (speed)\n",
"N2 = 200.0 #rpm (decreased speed) \n",
"Ra = 0.09 #ohm \n",
"#Induced emf at full-load\n",
"Eb = V - Ia*Ra #V\n",
"#Voltage across the armature at braking\n",
"Vb = V + Eb #V\n",
"#Resistance to limit the current to 240A\n",
"Rt = Vb/240 #ohm\n",
"#Resistance to be added in the circuit\n",
"R = Rt - Ra #ohm\n",
"\n",
"#(ii)\n",
"Tf = V*Ia/(2*3.14*N/60) #N-m (Full load torque)\n",
"# Initial braking torque/full-load torque = initial braking current/full-load current\n",
"\n",
"T_ini = Tf*(Ib/Ia) #N-m (initial braking torque)\n",
"\n",
"Eb_200 = Eb*N2/N #V (Back emf at 200 rpm)\n",
"Ia_200 = (V + Eb_200)/Rt #A (Current drawn at 200 rpm)\n",
"Tb_200 = Tf*Ia_200/Ia #N-m\n",
"\n",
"print \"Additional resistance = \",round(R,2),\"ohm.\"\n",
"print \"Initial braking torque = \",round(T_ini,2),\"N-m.\"\n",
"print \"Braking torque at 200rpm = \",round(Tb_200,2),\"N-m.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.9 , PAGE NO :- 1781"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Starting torque Ts = 0.25 *Tfl.\n"
]
}
],
"source": [
"'''A 400V 3-phase squirrel cage induction motor has a full load slip of 4%.A stand-still impedance of 1.54 ohm and the full load current\n",
"equal to 30A.The maximum starting current which may be taken from line is 75A.What taping must be provided on an auto-transformer starter\n",
"to limit the current to this value and what would be the starting torque available in terms of full-load torque ?'''\n",
"\n",
"import math as m\n",
"from sympy import Eq,solve,Symbol\n",
"\n",
"#considering Transformer action V2/V1 = I1/I2 = X\n",
"V1 = 400.0/(m.sqrt(3)) #V (applied voltage)\n",
"I1 = 75.0 #A (max starting current)\n",
"Z = 1.54 #ohm (impedance)\n",
"X = Symbol('X')\n",
"I2 = I1/X #A\n",
"V2 = Z*I2 #V\n",
"eq = Eq(V1*I1,V2*I2)\n",
"X = solve(eq) \n",
"X1 = X[1] #ohm\n",
"\n",
"I2 = I1/X1 #A\n",
"sfl = 0.04 # (full-load slip)\n",
"Ifl = 30.0 #A (full-load current)\n",
"\n",
"#Ts/Tfl = X^2*(Is/Ifl)^2*sfl\n",
"\n",
"Ts_Tfl = (X1*X1)*(I2/Ifl)*(I2/Ifl)*sfl # (Ts/Tfl)\n",
"print \"Starting torque Ts = \",round(Ts_Tfl,2),\"*Tfl.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.10 , PAGE NO :- 1782"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Additional resistance(constant torque) = 1.02 ohm.\n",
"Additional resistance(torque propotional to speed square) = 1.77 ohm.\n"
]
}
],
"source": [
"'''A 220V,10 HP shunt motor has field and armature resistances of 122ohm and 0.3ohm respectively.Calculate the resistance to be\n",
"inserted in the armature circuit to reduce the speed to 80% assuming motor efficiency at full load to be 80%.\n",
"(a)When torque is to remain constant.\n",
"(b)When torque is propotional to square of the speed.'''\n",
"\n",
"\n",
"V = 220.0 #V (applied voltage)\n",
"Rf = 122.0 #ohm (field resistance)\n",
"Ra = 0.3 #ohm (armature resistance)\n",
"\n",
"If = V/Rf #A (field current)\n",
"\n",
"m_out = 10*746 #W (motor output)\n",
"m_in = m_out/0.8 #W (motor input)\n",
"Il = m_in/V #A (line current)\n",
"\n",
"Ia = Il - If #A (armature current)\n",
"\n",
"Eb1 = V - Ia*Ra #V (back emf)\n",
"\n",
"#As flux is constant N2/N1 = Eb2/Eb1 and N2 = N1*0.8\n",
"\n",
"Eb2 = Eb1*0.8 #V (back emf at reduced speed)\n",
"\n",
"#(a) Torque remains constant ,hence Ia remains constant .Using Eb2 = V - Ia*R\n",
"Rt = (V-Eb2)/Ia #ohm (Total resistance required)\n",
"\n",
"#Therefore, additional resistance is\n",
"R = Rt - Ra #ohm\n",
"print \"Additional resistance(constant torque) = \",round(R,2),\"ohm.\"\n",
"\n",
"#(b) As (T2/T1) = (N2/N1)^2 and (T2/T1) = (Ia2/Ia1)\n",
"\n",
"T2_T1 = (0.8)*(0.8) # (T2/T1)\n",
"\n",
"Ia2 = Ia*T2_T1 #A (Changed armature current)\n",
"\n",
"#(b) Using Eb2 = V - Ia*R\n",
"Rt = (V-Eb2)/Ia2 #ohm (Total resistance required)\n",
"\n",
"\n",
"#Therefore, additional resistance is\n",
"R = Rt - Ra #ohm\n",
"print \"Additional resistance(torque propotional to speed square) = \",round(R,2),\"ohm.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.11 , PAGE NO :- 1783"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Initial braking torque = 713.33 N-m.\n",
"Electric braking torque at 1/2 speed = 539.96 N-m.\n"
]
}
],
"source": [
"'''A 37.5 HP, 220V DC shunt motor with a full load speed of 535 rpm is to be braked by plugging.Estimate the value of resistance \n",
"which should be placed in series with it to limit the initial braking current to 200 A.What would be the initial value of the\n",
"electric braking torque and the value when the speed had fallen to half its full load value?Armature resistance of motor is \n",
"0.086 ohm and full load armature current is 140A.'''\n",
"\n",
"V = 220.0 #V (applied voltage)\n",
"Ia = 140.0 #A (full-load armature current)\n",
"Ra = 0.086 #ohm (armature resistance)\n",
"Ib = 200.0 #A (braking current)\n",
"P = 37.5*746 #W (Power)\n",
"N = 535.0 #rpm (Speed)\n",
"Eb = V - Ia*Ra #V (Back emf)\n",
"#Total voltage during braking\n",
"Vb = Eb + V #V\n",
"\n",
"#Total resistance required is (using R = V/I)\n",
"Rt = Vb/Ib #ohm\n",
"Rt = round(Rt,2) #ohm\n",
"#Therefore,additional resistance required is\n",
"R = Rt - Ra #ohm\n",
"#We know that P = Torque*w where w is\n",
"w = 2*3.1416*N/60 #rad/s (angular velocity)\n",
"Tfl = P/w #N-m (full-load torque)\n",
"#As torque is propotional to I\n",
"#(Initial braking torque/Initial braking current) = (Full load torque/Full load current)\n",
"T_ini = Tfl*(Ib/Ia) #N-m (Initial braking torque)\n",
"\n",
"#As speed is propotional to back emf\n",
"Eb_2 = Eb/2 #V (Back emf at 1/2 speed)\n",
"Ib_2 = (V+Eb_2)/Rt #A (initial braking current at 1/2 speed)\n",
"\n",
"T_ini2 = Tfl*(Ib_2/Ia) #N-m (Initial braking torque at 1/2 speed)\n",
"print \"Initial braking torque = \",round(T_ini,2),\"N-m.\"\n",
"print \"Electric braking torque at 1/2 speed = \",round(T_ini2,2),\"N-m.\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## EXAMPLE 44.12 , PAGE NO :- 1783"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Speed when torque is constant is = 600.61 rpm.\n",
"Speed when torque is propotional to speed square = 546.14 rpm.\n"
]
}
],
"source": [
"'''A 500V series motor having armature and field resistances of 0.2 and 0.3 ohm runs at 500 rpm when taking 70A.Assumimg unsaturated\n",
"field find out its speed when field diverter of 0.648 ohm is used for following load whose torque\n",
"(a) remains constant\n",
"(b) varies as square of speed '''\n",
"\n",
"\n",
"from sympy import Eq,solve,Symbol\n",
"V = 500.0 #V (applied voltage)\n",
"Ra = 0.2 #ohm (armature resistance)\n",
"Rf = 0.3 #ohm (field resistance)\n",
"N1 = 500.0 #rpm (speed)\n",
"Ia = 70.0 #A (armature current)\n",
"Rd = 0.684 #ohm (diverter resistance)\n",
"Eb1 = V - Ia*(Ra + Rf) #V (Back emf)\n",
"\n",
"#(a)Let Ia2 be armature current when diverter is used\n",
"\n",
"Ia2 = Symbol('Ia2')\n",
"\n",
"#Now If2 (field current when diverter is used) is\n",
"If2 = Ia2*Rd/(Rf+Rd)\n",
"\n",
"#As Torque is constant Ia1*(Flux1) = Ia2*(Flux2) Also,Ia1=If1 is propotional to (flux1)\n",
"eq = Eq(Ia*Ia/If2-Ia2,0)\n",
"Ia2 = solve(eq) \n",
"Ia_2 = Ia2[1] #A (Armature current when diverter is used)\n",
"\n",
"If2 = Ia_2*Rd/(Rf+Rd) #A (field current when diverter is used)\n",
"\n",
"#Resistance of field with diverter\n",
"Rfd = Rf*Rd/(Rf+Rd) #ohm\n",
"#Total resistance\n",
"Rt = Rfd + Ra #ohm\n",
"\n",
"Eb2 = V - Ia_2*Rt #V (Back emf when diverter is used)\n",
"\n",
"#Now, (N1/N2) = (Eb1*flux1/Eb2*flux2) and flux is propotional to If\n",
"N2 = (Eb2/Eb1)*N1*(Ia/If2) #rpm\n",
"print \"Speed when torque is constant is = \",round(N2,2),\"rpm.\"\n",
"####################################################################################\n",
"\n",
"#(B)Let Ia22 be armature current when diverter is used\n",
"#Now, (N1/N2)^2 = T1/T2 As (T1/T2) = Ia1*Ia1/(Ia2*If2)\n",
"\n",
"Ia22 = Symbol('Ia22')\n",
"#Now If2 (field current when diverter is used) is\n",
"If2 = Ia22*Rd/(Rf+Rd)\n",
"\n",
"N1_N2a = Ia*Ia/(Ia22*If2) #N1_N2a -> (N1/N2)^2\n",
"#Also, N1/N2 = Eb1*flux2/(Eb2*flux1)\n",
"N1_N2b = Eb1*If2/((V - Ia22*Rt)*Ia) #N1_N2b -> (N1/N2)\n",
"\n",
"eq = Eq(N1_N2a,N1_N2b*N1_N2b)\n",
"Ia22 = solve(eq)\n",
"Ia_22 = Ia22[1] #A (Armature current when diverter is used)\n",
"\n",
"If2 = Ia_22*Rd/(Rf+Rd)\n",
"N1_N2b = Eb1*If2/((V - Ia_22*Rt)*Ia) \n",
"#Using equation of N1_N2b = N1/N2\n",
"N2 = N1/N1_N2b #rpm\n",
"\n",
"print \"Speed when torque is propotional to speed square = \",round(N2,2),\"rpm.\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## EXAMPLE 44.13 , PAGE NO :- 1784 "
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Additonal resistance required is = 5.9 ohm.\n"
]
}
],
"source": [
"'''A 200V series motor runs at 1000 rpm and takes 20A . Armature and field resistance is 0.4 ohm.Calculate the\n",
"resistance to be inserted in series so as to reduce the speed to 800 rpm,assuming torque to vary as cube of the\n",
"speed and unsaturated field.'''\n",
"\n",
"from sympy import Eq,Symbol,solve\n",
"\n",
"V = 200.0 #V (applied voltage)\n",
"N1 = 1000.0 #rpm (speed 1)\n",
"Raf = 0.4 #ohm (armature and field resistance)\n",
"N2 = 800.0 #rpm (speed 2)\n",
"Ia1 = 20.0 #A (armature current)\n",
"\n",
"\n",
"#Given, T1/T2 = (N1/N2)^3\n",
"\n",
"T1_T2a = (N1/N2)*(N1/N2)*(N1/N2) # (Ratio T1/T2)\n",
"\n",
"#Also T1/T2 = Ia1*flux1/Ia2*flux2 and Ia is propotional to flux\n",
"#Let Ia2 be armature current when speed is 800 rpm.\n",
"\n",
"Ia2 = Symbol('Ia2')\n",
"T1_T2b = Ia1*Ia1/(Ia2*Ia2)\n",
"eq = Eq(T1_T2a,T1_T2b)\n",
"Ia2 = solve(eq)\n",
"Ia_2 = Ia2[1] #A (armature current 2)\n",
"\n",
"Eb1 = V - Ia1*Raf #V (Back emf 1)\n",
"\n",
"#As Eb1/Eb2 = N1*I1/(N2*I2).Therefore Back emf 2 is\n",
"Eb2 = Eb1*(N2/N1)*(Ia_2/Ia1) #V (Back emf 2)\n",
"\n",
"#Also Eb2 = V - Ia2*Rt .Therefore total resistance required is\n",
"Rt = (V - Eb2)/Ia_2 #ohm\n",
"#Therefore,additional resistance required is\n",
"R = Rt - Raf #ohm\n",
"print \"Additonal resistance required is = \",round(R,2),\"ohm.\""
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## EXAMPLE 44.14 , PAGE NO :- 1785"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Speed at which torque is 75% of initial value = 242.79 rpm.\n"
]
}
],
"source": [
"'''A 220V,500 rpm DC shunt motor with an armature resistance of 0.08 ohm and full load armature current of 150A is to be braked by \n",
"plugging.Estimate the value of resistance which is to be placed in series with the armature to limit initial braking current to\n",
"200A.What would be the speed at which the electric braking torque is 75% of its initial value.'''\n",
"\n",
"from sympy import Eq,solve,Symbol\n",
"\n",
"V = 220.0 #V (applied voltage)\n",
"N1 = 500.0 #rpm (speed 1)\n",
"Ra = 0.08 #ohm (armature resistance)\n",
"Ia = 150.0 #A (armature current)\n",
"Ib = 200.0 #A (initial braking current)\n",
"\n",
"\n",
"Eb1 = V - Ia*Ra #V (Back emf) \n",
"#Voltage across armature when braking starts\n",
"Vb = V + Eb1 #V\n",
"\n",
"#Resistance in armature circuit\n",
"Rt = Vb/Ib #ohm \n",
"#Additional resistance required\n",
"R = Rt - Ra #ohm \n",
"#Since field flux is constant therefore 75% torque is produced when armature current is 75% of Ib.\n",
"#As (Eb1/Eb2) = (N1/N2)\n",
"N2 = Symbol('N2') #rpm\n",
"Eb2 = Eb1*(N2/N1) #V\n",
"\n",
"#Voltage across armature when braking starts is V1=V2 =>\n",
"V1 = (0.75*Ib)*Rt #V\n",
"V2 = V + Eb2 #V\n",
"eq = Eq(V1,V2)\n",
"N2 = solve(eq) #rpm\n",
"N_2 = N2[0] #rpm\n",
"print \"Speed at which torque is 75% of initial value =\",round(N_2,2),\"rpm.\""
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## EXAMPLE 44.15 , PAGE NO :- 1785"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Speed of motor with the shunted armature connection = 986.07 rpm.\n",
"Series motor can't be started on no-load.\n"
]
}
],
"source": [
"'''A D.C series motor operating at 250V D.C mains and draws 25A and runs at 1200 rpm Ra = 0.1 ohm and Rs = 0.3 ohm.A resistance of\n",
"25 ohm is placed in parallel with the armature of motor.Determine:\n",
"(i)The speed of motor with the shunted armature connection,if the magnetic circuit remains unsaturated and the load torque remains\n",
"constant.\n",
"(ii)No load speed of motor.'''\n",
"\n",
"from sympy import Eq,Symbol,solve\n",
"\n",
"V = 250.0 #V (applied voltage)\n",
"Ia = 25.0 #A (armature current)\n",
"N1 = 1200.0 #rpm (speed)\n",
"Ra = 0.1 #ohm (armature resistance)\n",
"Rse = 0.3 #ohm (series field resistance)\n",
"Rd = 25.0 #ohm (diverter resistance)\n",
"\n",
"#Let I2 flow from series winding , Ia2 be new armature current and Id be diverter current\n",
"\n",
"I2 = Symbol('I2')\n",
"Vd = V - Rse*I2 #V (Voltage across diverter)\n",
"Id = Vd/Rd #A (V=IR) \n",
"Ia2 = I2 - Id #A (new armature current)\n",
"\n",
"#AS T is constant, (flux1)*Ia1 = (flux2)*Ia2\n",
"\n",
"eq = Eq(Ia*Ia,(I2)*Ia2) # As, flux1/flux2 = Ia/I2\n",
"I2 = solve(eq)\n",
"I_2 = I2[1] #A (current through series winding)\n",
"\n",
"Ia2 = Ia*Ia/I_2 #A\n",
"Eb1 = V - Ia*(Ra+Rse) #V (Back emf 1) \n",
"\n",
"Eb2 = V - I_2*Rse - Ia2*Ra #V (Back emf 2)\n",
"\n",
"#N2/N1 = Eb2*flux1/Eb1*flux2\n",
"N2 = N1*(Eb2/Eb1)*(Ia/I_2) #rpm\n",
"print \"Speed of motor with the shunted armature connection =\",round(N2,2),\"rpm.\"\n",
"print \"Series motor can't be started on no-load.\""
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## EXAMPLE 44.16 , PAGE NO :- 1786"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Additional Resistance required in (i) is = 0.8 ohm.\n",
"Additional Resistance required in (ii) is = 1.27 ohm.\n"
]
}
],
"source": [
"'''A 4 pole,50 Hz,slip ring Induction Motor has rotor resistance and stand still reactance referred to stator of 0.2 ohm and 1 ohm\n",
"per phase respectively.At full load,it runs at 1440 rpm.Determine the value of resistance to be inserted in rotor in ohm/phase to\n",
"operate at a speed of 1200 rpm,if:\n",
"(i)Load torque remains constant (ii)Load torque varies as square of the speed\n",
"Neglect stator resistance and leakage reactance.'''\n",
"\n",
"from sympy import Eq,solve,Symbol\n",
"\n",
"p = 4.0 # poles\n",
"f = 50.0 #Hz (frequency)\n",
"R2 = 0.2 #ohm (rotor resistance)\n",
"X2 = 1.0 #ohm (stand still reactance)\n",
"N1 = 1440.0 #rpm (speed)\n",
"N2 = 1200.0 #rpm (new speed)\n",
"\n",
"Ns = 120*f/p #rpm (synchronus speed)\n",
"s1 = (Ns-N1)/Ns #rpm (slip 1)\n",
"s2 = (Ns-N2)/Ns #rpm (slip 2)\n",
"\n",
"#(i)Load torque is constant i.e (T1 = T2)\n",
"#T is propotional to (s/R2) , (T1/T2) = (s1/S2)*(R2/Rt).Therefore, new resistance required is \n",
"\n",
"Rt = (s2/s1)*R2 #ohm (total resistance)\n",
"r = Rt - R2 #ohm (additional resistance)\n",
"\n",
"print \"Additional Resistance required in (i) is =\",round(r,2),\"ohm.\"\n",
"\n",
"#(ii) Load torque varies as square of speed (i.e T1/T2 = (N1/N2)^2 )\n",
"T1_T2a = (N1/N2)*(N1/N2) #(T1/T2)\n",
"\n",
"Rt = Symbol('Rt')\n",
"T1_T2b = (s1*R2/(R2*R2 + (s1*X2)*(s1*X2)))/(s2*Rt/(Rt*Rt + (s2*X2)*(s2*X2)))\n",
"eq = Eq(T1_T2a,T1_T2b)\n",
"Rt = solve(eq)\n",
"R_t = Rt[1] #ohm (total resistance)\n",
"\n",
"r = R_t - R2 #ohm (additional resistance)\n",
"print \"Additional Resistance required in (ii) is =\",round(r,2),\"ohm.\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 2",
"language": "python",
"name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.11"
}
},
"nbformat": 4,
"nbformat_minor": 0
}