diff options
Diffstat (limited to 'Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal')
8 files changed, 2502 insertions, 0 deletions
diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/10-Introduction_to_Design.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/10-Introduction_to_Design.ipynb new file mode 100644 index 0000000..a73cfb9 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/10-Introduction_to_Design.ipynb @@ -0,0 +1,250 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 10: Introduction to Design" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.6: lead_compensation.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms Kv;\n", +"g=(Kv/(s*(s+1)));\n", +"// given Kv=12\n", +"Kv=12;\n", +"g=(12/(s*(s+1)));\n", +"G=syslin('c',g)\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G,fmin,fmax)\n", +"show_margins(G)\n", +"xtitle('uncompensated system')\n", +"[gm,freqGM]=g_margin(G)\n", +"[pm,freqPM]=p_margin(G)\n", +"disp(gm,'gain_margin=')\n", +"disp((freqGM*2*%pi),'gain margin freq=');\n", +"disp(pm,'phase margin=')\n", +"disp((freqPM*2*%pi),'phase margin freq=');\n", +"printf('since P.M is less than desired value so we need phase lead network')\n", +"disp('selecting zero of lead compensting network at w=2.65rad/sec and pole at w=7.8rad/sec and applying gain to account attenuation factor.')\n", +"gc=(1+0.377*s)/(1+0.128*s)\n", +"Gc=syslin('c',gc)\n", +"disp(Gc,'transfer function of lead compensator=');\n", +"G1=G*Gc\n", +"disp(G1,'overall transfer function=');\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G1,fmin,fmax);\n", +"show_margins(G1)\n", +"xtitle('compensated system')\n", +"[gm,freqGM]=g_margin(G1);\n", +"[pm,freqPM]=p_margin(G1);\n", +"disp(pm,'phase margin of compensated system=')\n", +"disp((freqPM*2*%pi),'gain cross over frequency=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.7: lead_compensation.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms Ka;\n", +"g=(Ka/(s^2*(1+0.2*s)));\n", +"// given Ka=10\n", +"Ka=10;\n", +"g=(10/(s^2*(1+0.2*s)));\n", +"G=syslin('c',g)\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G,fmin,fmax)\n", +"show_margins(G)\n", +"xtitle('uncompensated system')\n", +"[gm,freqGM]=g_margin(G)\n", +"[pm,freqPM]=p_margin(G)\n", +"disp(gm,'gain_margin=')\n", +"disp((freqGM*2*%pi),'gain margin freq=');\n", +"disp(pm,'phase margin=')\n", +"disp((freqPM*2*%pi),'phase margin freq=');\n", +"disp('since P.M is negative so system is unstable')\n", +"disp('selecting zero of lead compensating network at w=2.8 rad/sec and pole at w=14 rad/sec and applying gain to account attenuation factor.')\n", +"gc=(1+0.358*s)/(1+0.077*s)\n", +"Gc=syslin('c',gc)\n", +"disp(Gc,'transfer function of lead compensator=');\n", +"G1=G*Gc\n", +"disp(G1,'overall transfer function=');\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G1,fmin,fmax);\n", +"show_margins(G1)\n", +"xtitle('compensated system')\n", +"[gm,freqGM]=g_margin(G1);\n", +"[pm,freqPM]=p_margin(G1);\n", +"disp(pm,'phase margin of compensated system=')\n", +"disp((freqPM*2*%pi),'gain cross over frequency=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.8: lag_compnsation.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K;\n", +"g=(K/(s*(s+1)*(s+4)));\n", +"g=((K/4)/(s*(s+1)*(0.25*s+1)))\n", +"// given Kv=5 :velocity error constant\n", +"K=20;\n", +"g=(5/(s*(s+1)*(0.25*s+1)))\n", +"G=syslin('c',g)\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G,fmin,fmax)\n", +"show_margins(G)\n", +"xtitle('uncompensated system')\n", +"[gm,freqGM]=g_margin(G)\n", +"[pm,freqPM]=p_margin(G)\n", +"disp(gm,'gain_margin=')\n", +"disp((freqGM*2*%pi),'gain margin freq=');\n", +"disp(pm,'phase margin=')\n", +"disp((freqPM*2*%pi),'phase margin freq=');\n", +"disp('since P.M is negative so system is unstable')\n", +"disp('selecting zero of phase lag network at w=0.013 rad/sec and pole at w=0.13 rad/sec and applying gain to account attenuation factor')\n", +"gc=((s+0.13)/(10*(s+0.013)))\n", +"Gc=syslin('c',gc)\n", +"disp(Gc,'transfer function of lag compensator=');\n", +"G1=G*Gc\n", +"disp(G1,'overall transfer function=');\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G1,fmin,fmax);\n", +"show_margins(G1)\n", +"xtitle('compensated system')\n", +"[gm,freqGM]=g_margin(G1);\n", +"[pm,freqPM]=p_margin(G1);\n", +"disp(pm,'phase margin of compensated system=')\n", +"disp((freqPM*2*%pi),'gain cross over frequency=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 10.9: lag_and_lead_compensation.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K;\n", +"g=(K/(s*(0.1*s+1)*(0.2*s+1)));\n", +"// given Kv=30 :velocity error constsnt\n", +"K=30;\n", +"g=(30/(s*(0.1*s+1)*(0.2*s+1)))\n", +"G=syslin('c',g)\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G,fmin,fmax)\n", +"show_margins(G)\n", +"xtitle('uncompensated system')\n", +"[gm,freqGM]=g_margin(G)\n", +"[pm,freqPM]=p_margin(G)\n", +"disp(gm,'gain_margin=')\n", +"disp((freqGM*2*%pi),'gain margin freq=');\n", +"disp(pm,'phase margin=')\n", +"disp((freqPM*2*%pi),'phase margin freq=');\n", +"disp('since P.M is negative so system is unstable')\n", +"disp('If lead compenstion is used bandwidth will increase resulting in undesirable system sensitive to noise. If lag compensation is used bandwidth decreases so as to fall short of specified value of 12 rad/sec resulting in sluggish system')\n", +"disp('/n hence we use a lag-lead compensator')\n", +"// lag compensator\n", +"disp('selecting zero of phase lag network w=1 rad/sec and pole at w=0.1 rad/sec and applying gain to account attenuation factor')\n", +"gc1=((s+1)/(10*s+1));\n", +"Gc1=syslin('c',gc1)\n", +"disp(Gc1,'transfer function of lag compensator')\n", +"// lead compensator\n", +"disp('selecting zero of lead compensator at w=0.425rad/sec and pole at w=0.0425rad/sec ')\n", +"gc2=((0.425*s+1)/(0.0425*s+1));\n", +"Gc2=syslin('c',gc2)\n", +"disp(Gc2,'transfer function of lead compensator')\n", +"Gc=Gc1*Gc2 // transfer function of lag and lead sections\n", +"disp(Gc,'transfer function of lag and lead sections')\n", +"G1=G*Gc\n", +"disp(G1,'overall transfer function=');\n", +"fmin=0.01;\n", +"fmax=100;\n", +"bode(G1,fmin,fmax);\n", +"show_margins(G1)\n", +"xtitle('compensated system')\n", +"[gm,freqGM]=g_margin(G1);\n", +"[pm,freqPM]=p_margin(G1);\n", +"disp(pm,'phase margin of compensated system=')\n", +"disp((freqPM*2*%pi),'gain cross over frequency=')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/12-State_Variable_Analysis_and_Design.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/12-State_Variable_Analysis_and_Design.ipynb new file mode 100644 index 0000000..3ee5202 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/12-State_Variable_Analysis_and_Design.ipynb @@ -0,0 +1,346 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 12: State Variable Analysis and Design" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.12: check_for_controllability.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"A=[0 1 0;0 0 1;-6 -11 -6];\n", +"B=[0;0;1];\n", +"P=cont_mat(A,B);\n", +"disp(P,'Controllability Matrix=')\n", +"d=det(P)\n", +"if d==0\n", +" printf('matrix is singular, so system is uncontrollable');\n", +"else\n", +" printf('system is controllable');\n", +"end;" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.13: check_for_controllability.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"A=[0 1;-1 -2];\n", +"B=[1;-1];\n", +"P=cont_mat(A,B);\n", +"disp(P,'Controllability Matrix=')\n", +"d=determ(P)\n", +"if d==0\n", +" printf('matrix is singular, so system is uncontrollable');\n", +"else\n", +" printf('system is controllable');\n", +"end;" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.14: check_for_observability.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"A=[0 1 0;0 0 1;0 -2 -3];\n", +"B=[0;0;1];\n", +"C=[3 4 1];\n", +"P=obsv_mat(A,C);\n", +"disp(P,'Observability Matrix=');\n", +"d=det(P)\n", +"if d==0\n", +" printf('matrix is singular, so system is unobservable');\n", +"else\n", +" printf('system is observable');\n", +"end;" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.17: design_state_observer.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms g1 g2 g3 \n", +"poly(0,'l');\n", +"A=[1 2 0;3 -1 1;0 2 0];\n", +"C=[0;0;1];\n", +"G=[g1;g2;g3];\n", +"p=A-G*C;\n", +"[r c]=size(A);\n", +"I=eye(r,c);\n", +"q=lI-p; // lI-(A-G*C) where I is identity matrix\n", +"r=det(q) // detrminant of lI-(A-G*C)\n", +"// on equating r=0 we get\n", +"// characteristic equation\n", +"l^3+g3*(l)^2+(2*g2-9)l+2+6*g1-2*g2-7*g3=0;\n", +"printf('desired characteristic equation given is\n')\n", +"l^3+10*(l)^2+34*l+40=0;\n", +"// on comparing the coefficients og the two equations\n", +"// we get g1=25.2 g2=21.5 g3=10\n", +"g1=25.2;\n", +"g2=21.5;\n", +"g3=10;\n", +"disp(G)\n", +"\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.3: state_matrix.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',(2*s^2+6*s+7)/((s+1)^2*(s+2)))\n", +"SS=tf2ss(H)\n", +"[Ac,Bc,U,ind]=canon(SS(2),SS(3))" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.4: modal_matrix.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms m11 m12 m13 m21 m22 m23 m31 m32 m33 ^\n", +"s=%s;\n", +"poly(0,'l');\n", +"A=[0 1 0;3 0 2;-12 -7 -6]\n", +"[r c]=size(A)\n", +"I=eye(r,c);\n", +"p=l*I-A;\n", +"q=det(p); // determinant of li-p\n", +"// roots of q are\n", +"l1=-1;\n", +"l2=-2;\n", +"l3=-3;\n", +"x1=[m11;m21;m31];\n", +"q1=(l1*I-A)*1\n", +"// on solving we find m11=1 m21=-1 31=-1\n", +"m11=1;m21=-1;m31=-1;\n", +"x2=[m12;m22;m32];\n", +"q2=(l2*I-A)*1\n", +"// on solving we find m12=2 m22=-4 m32=1\n", +"m12=2;m22=-4;m32=1;\n", +"x3=[m13;m23;m33];\n", +"q3=(l3*I-A)*1\n", +"// on solving we get m13=1 m23=-3 m33=3\n", +"m13=1;m23=-3;m33=3;\n", +"// modal matrix is\n", +"M=[m11 m12 m13;m21 m22 23;m31 m32 m33]" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.5: obtain_time_response.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms t m\n", +"s=%s;\n", +"A=[1 0;1 1];\n", +"B=[1;1];\n", +"x=[1;0];\n", +"[r c]=size(A)\n", +"p=s*eye(r,c)-A // s*I-A \n", +"q=inv(p)\n", +"for i=1:r\n", +"for j=1:c\n", +" // inverse laplace of each element of Matrix q\n", +"q(i,j)=ilaplace(q(i,j),s,t);\n", +"end\n", +"end\n", +"disp(q,'phi(t)=') // State Transition Matrix\n", +"t=t-m;\n", +"q=eval(q)\n", +"// Integrate q w.r.t m\n", +"r=integrate(q*B,m)\n", +"m=0 // Upper limit is t\n", +"g=eval(r) // Puting upper limit in q\n", +"m=t // Lower limit is 0\n", +"h=eval(r) // Putting lower limit in q\n", +"y=(h-g);\n", +"disp(y,'y=')\n", +"printf('x(t)=phi(t)*x(0)+integrate(phi(t-m*B) w.r.t m from 0 to t)')\n", +"y1=(q*x)+y;\n", +"disp(y1,'x(t)=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.6: resolvant_matrix.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms t\n", +"s=%s;\n", +"A=[1 0;1 1];\n", +"[r c]=size(A)\n", +"p=s*eye(r,c)-A \n", +"// resolvent matrix\n", +"q=inv(p)\n", +"disp(q,'phi(s)=')\n", +"for i=1:r\n", +"for j=1:c\n", +"q(i,j)=ilaplace(q(i,j),s,t) \n", +"end\n", +"end\n", +"disp(q,'phi(t)=') // state transition matrix" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 12.7: state_transition_matrix_and_state_response.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms t m\n", +"s=%s;\n", +"A=[0 1;-2 -3];\n", +"B=[0;2];\n", +"x=[0;1];\n", +"[r c]=size(A)\n", +"p=s*eye(r,c)-A\n", +"q=inv(p)\n", +"for i=1:r\n", +"for j=1:c\n", +"q(i,j)=ilaplace(q(i,j),s,t)\n", +"end\n", +"end\n", +"disp(q,'phi(t)=') // state transition matrix\n", +"t=t-m;\n", +"q=eval(q)\n", +"// Integrate q w.r.t m\n", +"r=integrate(q*B,m)\n", +"m=0 // Upper limit is t\n", +"g=eval(r) // Puting upper limit in q\n", +"m=t // Lower limit is 0\n", +"h=eval(r) // Putting lower limit in q\n", +"y=(h-g);\n", +"disp(y,'y=')\n", +"printf('x(t)=phi(t)*x(0)+integrate(phi(t-m*B) w.r.t m from 0 to t)')\n", +"y1=(q*x)+y;\n", +"disp(y1,'x(t)=')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/2-Mathematical_Models_of_Physical_Systems.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/2-Mathematical_Models_of_Physical_Systems.ipynb new file mode 100644 index 0000000..678c7f5 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/2-Mathematical_Models_of_Physical_Systems.ipynb @@ -0,0 +1,98 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 2: Mathematical Models of Physical Systems" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.3: signal_flow_graph.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms L C R1 R2\n", +"// forward path denoted by P! and loop by L1,L2 and so on\n", +"// path factor by D1 and graph determinant by D\n", +"P1=1/(s*L*s*C);\n", +"L1=-R1/(s*L);\n", +"L2=-1/(s*R2*C);\n", +"L3=-1/(s^2*L*C);\n", +"D1=1;\n", +"D=1-(L1+L2+L3);\n", +"Y=(P1*D1)/D;\n", +"disp(Y,'Transfer function=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2.4: transfer_function.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms xv Qf Qo Cf Co V Qw Kv \n", +"Qo=Qw+Qf;\n", +"// rate of salt inflow\n", +"mi=Qf*Cf;\n", +"// rate of salt outflow\n", +"mo=Qo*Co;\n", +"// rate of salt accumulation\n", +"ma=diff(V*Co,t);\n", +"mi=ma+mo;\n", +"Qf*Cf=V*diff(Co,t)+Qo*Co;\n", +"Qf=Kv*xv;\n", +"K=Cf*Kv/Qo;\n", +"G=V/Qo;\n", +"G*diff(Co,t)+Co=K*xv;\n", +"// taking laplace\n", +"G*s*Co+Co=K*xv;\n", +"// transfer function= Co/xv\n", +"Co/xv=K/(G*s+1);\n", +"" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/3-Feedback_Characteristics_of_control_sytems.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/3-Feedback_Characteristics_of_control_sytems.ipynb new file mode 100644 index 0000000..c8ca2af --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/3-Feedback_Characteristics_of_control_sytems.ipynb @@ -0,0 +1,255 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 3: Feedback Characteristics of control sytems" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.2: sensitivity_of_transfer_function.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms K;\n", +"s=%s;\n", +"G=syslin('c',25(s+1)/(s+5));\n", +"p=K;\n", +"q=s^2+s;\n", +"J=p/q;\n", +"F=G*J;\n", +"T=F/(1+F); // Closed loop transfer function\n", +"disp(T,'C(s)/R(s)')\n", +"// sensitivity w.r.t K = dT/dK*K/T\n", +"S=(diff(T,K))*(K/T)\n", +"disp(S,'Sensitivity')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_a: sensitivity_of_transfer_function.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms K1 K t;\n", +"s=%s;\n", +"p=K1*K;\n", +"q=t*s+1+(K1*K);\n", +"T=p/q;\n", +"disp(T,'V(s)/R(s)')\n", +"// sensitivity w.r.t K is dT/dK*K/T\n", +"S=(diff(T,K))*(K/T)\n", +"// given K1=50 K=1.5\n", +"s=0\n", +"S=horner(S,s)\n", +"K1=50;\n", +"K=1.5;\n", +"S=1/(1+K1*K)\n", +"disp(S,'sensitivity=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_b: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms A K K1 t\n", +"s=%s;\n", +"p=K1*K*A;\n", +"q=s*(1+(t*s)+(K1*K));\n", +"K=1.5;\n", +"K1=50;\n", +"V=p/q\n", +"v=limit(s*V,s,0)\n", +"// given steady state speed = 60km/hr\n", +"A=60*(1+(K1*K))/(K1*K)\n", +"// steady error e(ss)=A-v\n", +"v=60;\n", +"e=A-v;\n", +"disp(e,'e(ss)=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_c: calculation_of_slope.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// under stalled conditions\n", +"syms Kg K1 D;\n", +"A=60.8;\n", +"A*K1=Kg*D;\n", +"// given Kg=100 \n", +"Kg=100;\n", +"K1=50;\n", +"D=(A*K1)/Kg;\n", +"disp(D,'upslope=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_d: calculation_of_slope.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// steady speed=10km/hr\n", +"syms K Kg D\n", +"(((A-10)*K1)-(-D*Kg))K=100;\n", +"A=(60.8*10)/60;\n", +"K=1.5;\n", +"Kg=100;\n", +"D=((100/K)-((A-10)*K))/Kg;\n", +"disp(D,'Down slope=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_f: calculation_of_input.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// for open loop system\n", +"// given speed=60km/hr\n", +"syms R K1 K;\n", +"(R*K1*K)=60\n", +"K1=50;\n", +"K=1.5;\n", +"R=60/(K1*K)\n", +"disp(R,'Input open=')\n", +"// for closed loop\n", +"R=60(1+(K1*K))/(K1*K)\n", +"disp(R,'Input closed=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3.3_g: calculation_of_time.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// for open loop\n", +"syms t g s;\n", +"s=%s;\n", +"K1=50;\n", +"K=1.5;\n", +"g=20;\n", +"V=syslin('c',((K1*K)*0.8)/(s*((g*s)+1)))\n", +"// taking inverse laplace\n", +"v=ilaplace(V,s,t)\n", +"v=60(11-%e^(-t/20))\n", +"// given v=90%\n", +"v=0.9;\n", +"t=-20*log(1-v);\n", +"disp(t,'time open=')\n", +"// for closed loop\n", +"syms K' g'\n", +"s=%s;\n", +"V=syslin('c',(60.8*K')/(s*((g'*s)+1)))\n", +"// taking inverse laplace\n", +"v=ilaplace(V,s,t)\n", +"// given \n", +"K'=75/76; \n", +"g'=.263;\n", +"v=60(1-%e^(-t/.263))\n", +"// at v=90%\n", +"v=0.9;\n", +"t=-.263*log(1-(v/60));\n", +"disp(t,'time closed=')\n", +"" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/5-Time_Response_analysis_design_specifications_and_performance_indices.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/5-Time_Response_analysis_design_specifications_and_performance_indices.ipynb new file mode 100644 index 0000000..f3fbf57 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/5-Time_Response_analysis_design_specifications_and_performance_indices.ipynb @@ -0,0 +1,341 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 5: Time Response analysis design specifications and performance indices" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.2_2: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// given Qi(s)=0.04/s^2\n", +"Qi=0.04/s^2;\n", +"e=limit(s*Qi*H,s,0)\n", +"disp(e,'Steady stste eror=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.2: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s\n", +"syms K J f\n", +"K=60; // given\n", +"J=10; // given\n", +"p=K/J\n", +"q=K/J+(f/J)*s+s^2\n", +"G=p/q;\n", +"disp(G,'Qo(s)/Qi(s)=')\n", +"zeta=0.3; // given\n", +"cof1=coeffs(q,'s',0)\n", +"// on comparing the coefficients\n", +"Wn=sqrt(cof1)\n", +"cof2=coeffs(q,'s',1)\n", +"// 2*zeta*Wn=cof2\n", +"f/J=2*zeta*Wn\n", +"r=s^2+f/J\n", +"s=s^2+f/J+K/J\n", +"H=r/s;\n", +"disp(H,'Qe(s)/Qi(s)=')\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.3_2: transfer_function.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms Kp Ka Kt Kd J f\n", +"// given \n", +"J=0.4; \n", +"Kp=0.6; \n", +"Kt=2; \n", +"f=2;\n", +"Ka=5;\n", +"p=Kp*Ka*Kt\n", +"q=s^2+((f+Ka*Kd*Kt)/J)*s+(Kp*Ka*Kt)/J\n", +"G=p/q;\n", +"disp(G,'Qm(s)/Qr(s)=')\n", +"cof_1=coeffs(q,'s',0)\n", +"// on comparing the coefficients\n", +"Wn=sqrt(cof_1)\n", +"zeta=1 // given\n", +"cof_2=coeffs(q,'s',1)\n", +"// 2*zeta*Wn=cof_2\n", +"Kd=(2*zeta*sqrt(Kp*J*Ka*Kt)-f)/(Ka*Kt)\n", +"disp(Kd,'Tachogenertor constant=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.3: transfer_function.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms Kp Ka Kt J f\n", +"// given \n", +"J=0.4; \n", +"Kp=0.6; \n", +"Kt=2; \n", +"f=2;\n", +"p=Kp*Ka*Kt\n", +"q=s^2+f/J+(Kp*Ka*Kt)/J\n", +"G=p/q;\n", +"disp(G,'Qm(s)/Qr(s)=')\n", +"cof_1=coeffs(q,'s',0)\n", +"// on comparing the coefficients\n", +"// Wn=sqrt(cof_1)\n", +"Wn=10;\n", +"Ka=(Wn)^2*J/(Kp*f)\n", +"disp(Ka,'Amplifier Constant=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4_1: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms Wn zeta Kv Ess\n", +"s=%s;\n", +"p=poly([8 2 1],'s','coeff'); // characteristic equation\n", +"z=coeff(p);\n", +"Wn=sqrt(z(1,1))\n", +"zeta=z(1,2)/(2*Wn)\n", +"Kv=z(1,1)/z(1,2)\n", +"Ess=1/Kv // Steady state error for unit ramp i/p\n", +"disp(Ess,'Steady state Error=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4_2: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// with derivative feedback\n", +"// characteristic equation is\n", +"syms a\n", +"s=%s;\n", +"p=s^2+(2+(8*a))*s+8=0\n", +"zeta=0.7 // given\n", +"Wn=2.828;\n", +"cof_1=coeffs(p,'s',1)\n", +"// on comparing 2*zeta*Wn=cof_1\n", +"a=((2*zeta*Wn)-2)/8\n", +"disp(a,'Derivative feedback=')\n", +"cof_2=coeffs(p,'s',0)\n", +"cof_1=2+8*0.245;\n", +"Kv=cof_2/cof_1;\n", +"Ess=1/Kv\n", +"disp(Ess,'Steady state error=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.4_3: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// let the char equation be\n", +"syms Ka\n", +"s=%s;\n", +"p=s^2+(2+(a*Ka))*s+Ka=0\n", +"cof_1=coeffs(p,'s',0)\n", +"// Wn^2=cof_1\n", +"Wn=sqrt(cof_1)\n", +"cof_2=coeffs(p,'s',1)\n", +"// 2*zeta*Wn=cof_2\n", +"Kv=cof_1/cof_2;\n", +"Ess=1/Kv;\n", +"// given Ess=0.25\n", +"Ess=0.25;\n", +"Ka=2/(Ess-a)\n", +"disp(Ka.'Ka=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.8: steady_state_error.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K V\n", +"p=s^2+(100*K)*s+100=0\n", +"cof_1=coeffs(p,'s',0)\n", +"Wn=sqrt(cof_1)\n", +"zeta=1 // given\n", +"cof_2=coeffs(p,'s',1)\n", +"// 2*zeta*Wn=cof_2\n", +"K=(2*Wn*zeta)/100\n", +"// For ramp input\n", +"R=V/s^2\n", +"E=R/p\n", +"// steady state error\n", +"e=limit(s*E(s),s,0)\n", +"disp(e,'e(ss)=')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 5.9: state_variable_analysis.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms t m\n", +"A=[0 1;-100 -20];\n", +"B=[0;100];\n", +"C=[1 0];\n", +"x=[0;0];\n", +"[r c]=size(A)\n", +"p=s*eye(r,c)-A\n", +"q=inv(p);\n", +"disp(q,'phi(s)=') // Resolvant matrix\n", +"for i=1:r;\n", +"for j=1:c;\n", +"q(i,j)=ilaplace(q(i,j),s,t)\n", +"end\n", +"end\n", +"disp(q,'phi(t)=') // State transition matrix\n", +"t=t-m;\n", +"q=eval(q)\n", +"// Integrate q w.r.t m\n", +"r=integrate(q*B,m)\n", +"m=0 // Upper limit is t\n", +"g=eval(r) // Puting upper limit in q\n", +"m=t // Lower limit is 0\n", +"h=eval(r) // Putting lower limit in q\n", +"y=(h-g);\n", +"disp(y,'y=')\n", +"printf('x(t)=phi(t)*x(0)+integrate(phi(t-m*B) w.r.t m from 0 to t)')\n", +"y1=(q*x)+y;\n", +"disp(y1,'x(t)=')\n", +"// transfer function\n", +"t=C*q*B;\n", +"disp(t,'T(s)=')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/6-Concepts_of_stability_and_Algebraic_Criteria.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/6-Concepts_of_stability_and_Algebraic_Criteria.ipynb new file mode 100644 index 0000000..2d27c71 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/6-Concepts_of_stability_and_Algebraic_Criteria.ipynb @@ -0,0 +1,473 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 6: Concepts of stability and Algebraic Criteria" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.10: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"p=s^3+7*s^2+25*s+39\n", +"// to check if the roots lie left of s=-1\n", +"// substitute s=s-1\n", +"p=(s-1)^3+7*(s-1)^2+25*(s-1)+20\n", +"r=routh_t(p)\n", +"printf('All the signs of elements first column are positive hence the roots lie left of s=-1')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.11_a: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K\n", +"// the system characteristic eq can be written as\n", +"p=s^3+8.5*s^2+20*s+12.5(1+K)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"cof_a_3=coeffs(p,'s',3);\n", +"r=[cof_a_0 cof_a_1 cof_a_2 cof_a_3]\n", +"n=length(r);\n", +"routh=[r([4,2]);r([3,1])]\n", +"routh=[routh;-det(routh)/routh(2,1),0]\n", +"t=routh(2:3,1:2);\n", +"routh=[routh;-det(t)/routh(3,1),0]\n", +"disp(routh,'routh=');\n", +"// for limiting value of K\n", +"routh(3,1)=0\n", +"K=12.6;\n", +"disp(K,'Limiting value of K')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.11_b: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms zeta Wn ts z\n", +"// settling time ts=4/zeta*Wn\n", +"// given ts=4sec\n", +"ts=4;\n", +"zeta*Wn=ts/4\n", +"printf('now the real part of dominant root should be -1 or more')\n", +"// substituting s=s-1\n", +"p=(s-1)^3+8.5*(s-1)^2+20*(s-1)+12.5*(1+K)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"cof_a_3=coeffs(p,'s',3);\n", +"r=[cof_a_0 cof_a_1 cof_a_2 cof_a_3]\n", +"n=length(r);\n", +"routh=[r([4,2]);r([3,1])]\n", +"routh=[routh;-det(routh)/routh(2,1),0]\n", +"t=routh(2:3,1:2);\n", +"routh=[routh;-det(t)/routh(3,1),0]\n", +"disp(routh,'routh=');\n", +"// for limiting value of K\n", +"routh(3,1)=0\n", +"K=2.64\n", +"disp(K,'Limiting value of K for settling time of 4s=')\n", +"// roots of char eq at K=2.64\n", +"g=s^3+8.5*s^2+20*s+12.5*(1+2.64)\n", +"roots(g)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.1: hurwitz_criterio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"p=s^4+8*s^3+18*s^2+16*s+5\n", +"r=coeff(p)\n", +"D1=r(4)\n", +"d2=[r(4) r(5);r(2) r(3)]\n", +"D2=det(d2);\n", +"d3=[r(4) r(5) 0;r(2) r(3) r(4);0 r(1) r(2)]\n", +"D3=det(d3);\n", +"d4=[r(4) r(5) 0 0;r(2) r(3) r(4) r(5);0 r(1) r(2) r(3);0 0 0 r(1)]\n", +"D4=det(d4);\n", +"disp(D1,'D1=')\n", +"disp(D2,'D2=')\n", +"disp(D3,'D3=')\n", +"disp(D4,'D4=')\n", +"printf('Since all the determinants are positive the system is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.2: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"p=s^4+8*s^3+18*s^2+16*s+5\n", +"r=routh_t(p)\n", +"m=coeff(p)\n", +"l=length(m)\n", +"c=0;\n", +"for i=1:l\n", +"if (r(i,1)<0)\n", +"c=c+1;\n", +"end \n", +"end\n", +"if(c>=1)\n", +"printf('System is unstable')\n", +"else ('Sysem is stable')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.3: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"p=3*s^4+10*s^3+5*s^2+5*s+2\n", +"r=routh_t(p)\n", +"m=coeff(p)\n", +"l=length(m)\n", +"c=0;\n", +"for i=1:l\n", +"if (r(i,1)<0)\n", +"c=c+1;\n", +"end \n", +"end\n", +"if(c>=1)\n", +"printf('System is unstable')\n", +"else ('Sysem is stable')\n", +"end" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.4: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms Kv Kd Kp Kt\n", +"p=s^3+(1+(Kv*Kd))*s^2+(Kv*Kp)*s+(Kp*Kt)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"cof_a_3=coeffs(p,'s',3);\n", +"r=[cof_a_0 cof_a_1 cof_a_2 cof_a_3]\n", +"n=length(r);\n", +"routh=[r([4,2]);r([3,1])]\n", +"routh=[routh;-det(routh)/routh(2,1),0]\n", +"t=routh(2:3,1:2);\n", +"routh=[routh;-det(t)/routh(3,1),0]\n", +"disp(routh,'routh=');\n", +"// for stability r(:,1)>0\n", +"// for the given table\n", +"b=routh(3,1)\n", +"disp('for stability'b,'>0')\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.5: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K\n", +"p=(1+K)*s^2+((3*K)-0.9)*s+(2K-1)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"r=[cof_a_0 cof_a_1 cof_a_2]\n", +"n=length(r);\n", +"routh=[r([3,1]);r(2),0];\n", +"routh=[routh;-det(routh)/routh(2,1),0];\n", +"disp(routh,'routh=')\n", +"// for no root in right half\n", +"// routh(1,1),routh(2,1),routh(3,1)>0\n", +"routh(1,1)=0\n", +"routh(2,1)=0\n", +"routh(3,1)=0\n", +"// combining the result\n", +"K=0.9/3;\n", +"disp(K,'For no roots in right half=')\n", +"// for 1 pole in right half i.e. one sign change\n", +"//routh(1,1)>0 n routh(3,1)<0\n", +"disp('For one pole in right half, -1<K<0.05')\n", +"// for 2 poles in right half\n", +"// routh(2,1)<0 n routh(3,1)>0\n", +"disp('For 2 poles in right half, 0.05<K<0.3')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.6: routh_criterio.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K\n", +"p=s^2-(K+2)*s+((2*K)+5)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"r=[cof_a_0 cof_a_1 cof_a_2]\n", +"n=length(r);\n", +"routh=[r([3,1]);r(2),0];\n", +"routh=[routh;-det(routh)/routh(2,1),0];\n", +"disp(routh,'routh=')\n", +"// for system to be stable\n", +"routh(2,1)>0\n", +"K<-2;\n", +"routh(3,1)>0\n", +"K>-2.5;\n", +"disp('For stable system, -2>K>-2.5')\n", +"// for limited stability\n", +"routh(2,1)=0\n", +"K=-2\n", +"routh(3,1)=0\n", +"K=-2.5\n", +"disp('For limted stable system K=-2 and K=-2.5')\n", +"// for unstable system\n", +"disp('For unstable system K<-2 or K>-2.5')\n", +"roots(p) // gives the roots of the polynomial m\n", +"// for critically damped case\n", +"g=(K+2)^2-4*((2*K)+5)\n", +"roots(g)\n", +"// for stablity K=6.47 is unstable\n", +"// for critical damping K=-2.47\n", +"disp('For underdamded case, -2>K>-2.47')\n", +"disp('for overdamped case, -2.47>K>-2.5')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.7: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms eps\n", +"p=s^5+s^4+2*s^3+2*s^2+3*s+5\n", +"r=coeff(p);\n", +"n=length(r);\n", +"routh=[r([6,4,2]);r([5,3,1])]\n", +"syms eps;\n", +"routh=[routh;eps,-det(routh(1:2,2:3))/routh(2,2),0];\n", +"routh=[routh;-det(routh(2:3,1:2))/routh(3,1),-det(routh(2:3,2:3))/routh(4,2),0];\n", +"routh=[routh;-det(routh(4:5,1:2))/routh(5,1),0,0];\n", +"disp(routh,'routh=')\n", +"// to check stability\n", +"routh(4,1)=8-limit(5/eps,eps,0);\n", +"disp(routh(4,1),'routh(4,1)=')\n", +"routh(5,1)=limit(routh(5,1),eps,0);\n", +"disp(routh(5,1),'routh(5,1)=')\n", +"printf('There are two sign changes of first column hence the system is unstable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.8: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"p=s^6+2*s^5+8*s^4+12*s^3+20*s^2+16*s+16\n", +"r=routh_t(p)\n", +"roots(p)\n", +"disp(0,'the number of real part of roots lying in the right half')\n", +"printf('System is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 6.9: routh_array.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K a\n", +"p=s^4+10*s^3+32*s^2+(K+32)*s+(K*a)\n", +"cof_a_0=coeffs(p,'s',0);\n", +"cof_a_1=coeffs(p,'s',1);\n", +"cof_a_2=coeffs(p,'s',2);\n", +"cof_a_3=coeffs(p,'s',3);\n", +"cof_a_4=coeffs(p,'s',4);\n", +"r=[cof_a_0 cof_a_1 cof_a_3 cof_a_4]\n", +"n=length(r);\n", +"routh=[r([5,3,1]);r([4,2]),0]\n", +"routh=[routh;-det(routh(1:2,1:2))/routh(2,1),-det(routh(1:2,2:3))/routh(2,2),0];\n", +"routh=[routh;-det(routh(2:3,1:2))/routh(3,1),-det(routh(2:3,2:3))/routh(3,2),0];\n", +"routh=[routh;-det(routh(3:4,1:2))/routh(4,1),0,0];\n", +"disp(routh,'routh=')\n", +"// for the given system to be stable\n", +"routh(3,1)>0\n", +"K<288;\n", +"routh(4,1)>0\n", +"(288-K)*(K+32)-100(K*a)>0\n", +"// let K=200\n", +"K=200;\n", +"a=((288-K)*(K+32))/(100*K)\n", +"// velocity error \n", +"Kv=(K*a)/(4*2*4);\n", +"// % velocity error\n", +"Kvs=100/Kv\n", +"disp(a,'control parameter=')\n", +"disp(K,'Gain=')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/7-The_Root_Locus_Technique.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/7-The_Root_Locus_Technique.ipynb new file mode 100644 index 0000000..e8ab155 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/7-The_Root_Locus_Technique.ipynb @@ -0,0 +1,271 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 7: The Root Locus Technique" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.10: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms Kh\n", +"s=%s;\n", +"G=syslin('c',10*Kh*(s+0.04)*(s+1)/((s+0.5)*(s^2-(0.4*s)+0.2)*(s+8)));\n", +"evans(G,3)\n", +"Kh=kpure(G)\n", +"K=10*Kh\n", +"zeta=1/(2)^(1/2);\n", +"wn=.575;\n", +"sgrid(zeta,wn)\n", +"K=-1/real((2*horner(G,[1 %i]*locate(1))));\n", +"printf('The zeta=1/(2)^1/2 line intersects the root locus at two points with K1=1.155 and K2=0.79')\n", +"Kh1=0.156;\n", +"Kh2=0.079;\n", +"// from the block diagram \n", +"Td(s)=1/s;\n", +"E(s)=C(s)=G/(1+(G*Kh*(s+1))/(s+8))*Td(s);\n", +"// substituting value of G\n", +"F=s*E(s)=10*Kh/(1+(10*Kh));\n", +"// steay state error\n", +"ess=limit(F,s,0)\n", +"// for Kh1=0.156\n", +"ess=0.609;\n", +"// for Kh2=0.079\n", +"ess=0.44;\n", +"\n", +"\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.1: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',(k*(s+1)*(s+2))/(s*(s+3)*(s+4)));\n", +"evans(H,5)\n", +"printf('There are three branches of root locus starting with K=0 and poles s=0,-3,-4.')\n", +"printf('As k increases two branches terminate at zeros s=-1,-2 and one at infinity')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.2: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',1+(k/(s*(s+1)*(s+2))));\n", +"evans(H,5)\n", +"printf('The branches of root locus starts with K=0 and poles s=0,-1,-2.')\n", +"printf('Since there is no open loop zero the branches terminate at infinity')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.3: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',1+(k/(s*(s+1)*(s+2))))\n", +"evans(H,5)\n", +"d=derivat(H)\n", +"p=numer(d)\n", +"a=roots(p) // a=breakaway point\n", +"disp(a,'breakaway ppoint=')\n", +"\n", +" " + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.4: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',k/(s*(s+4)*(s^2+(4*s)+20)))\n", +"evans(H,1000)\n", +"printf('Since there are no open loop zeros all branches terminate at infimity')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.6: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',k/(s*(s+3)*(s^2+(2*s)+2)))\n", +"evans(H,10)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.8: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms K\n", +"s=%s;\n", +"G=syslin('c',(K*(s+1)*(s+2))/((s+0.1)*(s-1)))\n", +"evans(G)\n", +"n=2;\n", +"disp(n,'no of poles=')\n", +"m=2;\n", +"disp(m,'no of zeroes=')\n", +"K=kpure(G)\n", +"disp(K,'value of K where RL crosses jw axis=')\n", +"d=derivat(G)\n", +"p=numer(d)\n", +"a=roots(p); // a=breakaway points\n", +"disp(a,'breakaway points=')\n", +"for i=1:2\n", +" K=-(a(i,1)+0.1)*(a(i,1)-1)/((a(i,1)+1)*(a(i,1)+2))\n", +" disp(a(i,1),'s=')\n", +" disp(K,'K=')\n", +"end\n", +"printf('zeta=1 is achieved when the two roots are equal and negative(real).This happens at the breakaway point in the left half s-plane/n')\n", +"zeta=1;\n", +"wn=0.6;\n", +"sgrid(zeta,wn)\n", +"K=-1/real(horner(G,[1 %i]*locate(1)));\n", +"disp(K,'The corresponding value of gain is=')\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 7.9: root_locus.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms K\n", +"s=%s;\n", +"G=syslin('c',(K*(s+4/3))/(s^2*(s+12)))\n", +"evans(G,60)\n", +"d=derivat(G)\n", +"p=numer(d)\n", +"a=roots(p) // a=breakaway points\n", +"disp(a,'Breakaway points=')\n", +"printf('Equal roots are at s=-4')\n", +"printf('/n Value of K at s=-4=')\n", +"K=4*4*8/(4-(4/3))\n", +"disp(K)" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/9-Stability_in_Frequency_Domain.ipynb b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/9-Stability_in_Frequency_Domain.ipynb new file mode 100644 index 0000000..99be3d2 --- /dev/null +++ b/Control_Systems_Engineering_by_I_J_Nagrath_And_M_Gopal/9-Stability_in_Frequency_Domain.ipynb @@ -0,0 +1,468 @@ +{ +"cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 9: Stability in Frequency Domain" + ] + }, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.10: gm_and_pm_using_nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K\n", +"H=syslin('c',K/(s*(0.2*s+1)*(0.05*s+1)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-1 1 -5 1])\n", +"gm=g_margin(H) // gain margin\n", +"pm=p_margin(H) // phase margin" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.11: bode_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',10/(s*(0.1*s+1)*(0.05*s+1)))\n", +"fmin=0.1;\n", +"fmax=100;\n", +"bode(H,fmin,fmax)\n", +"show_margins(H)\n", +"gm=g_margin(H)\n", +"pm=p_margin(H)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.13_a: bode_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',(8*(s+4))/((s-1)*(s-2)))\n", +"fmin=0.1;\n", +"fmax=100;\n", +"bode(H,fmin,fmax)\n", +"show_margins(H)\n", +"gm=g_margin(H)\n", +"pm=p_margin(H)" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.13_b: bode_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"syms K\n", +"H=syslin('c',(K*(s+4))/((s-1)*(s-2)))\n", +"fmin=0.1;\n", +"fmax=100;\n", +"bode(H,fmin,fmax)\n", +"show_margins(H)\n", +"// for phase margin =30\n", +"printf('From bode plot it can be seen that gain should be reduced by 4db')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.14: m_circles.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',10/(s*((0.1*s)+1)*((0.5*s)+1)))\n", +"fmin=0.1;\n", +"fmax=100;\n", +"clf()\n", +"black(H,0.1,100)\n", +"chart(list(1,0))\n", +"gm=g_margin(H)\n", +"pm=p_margin(H)\n", +"printf('For gain margin of 20 db plot is shifted downwards by 8 db and a phase margin of 24 degrees is obtained if curve is shifted upwards by 3.5 db')\n", +"\n", +"\n", +"\n", +"\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.15: m_circles.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',10/(s*((0.1*s)+1)*((0.05*s)+1)))\n", +"fmin=0.1;\n", +"fmax=100;\n", +"clf()\n", +"black(H,0.1,100)\n", +"chart(list(1,0))\n", +"gm=g_margin(H)\n", +"pm=p_margin(H)\n", +"printf('For gain margin of 20 db plot is shifted downwards by 8 db and a phase margin of 24 degrees is obtained if curve is shifted upwards by 3.5 db')\n", +"\n", +"\n", +"\n", +"\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.1: nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K T1 T2\n", +"H=syslin('c',K/((T1*s+1)*(T2*s+1)));\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"printf('Since P=0(no of poles in RHP) and the nyquist contour does not encircle the point -1+j0')\n", +"printf('System is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.2: nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',(s+2)/((s+1)*(s-1)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"printf('Since P=1 and the pt. -1+j0 is encircled once by the locus')\n", +"printf('Hence N=1 therefore, Z=0(no of zeros in RHP)')\n", +"printf('System is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.3: nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K T\n", +"H=syslin('c',K/(s*(T*s+1)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-1 1 -1 1])\n", +"printf('Since P=0(no of poles in RHP) and the nyquist contour does not encircle the point -1+j0')\n", +"printf('System is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.4: nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"H=syslin('c',(4*s+1)/(s^2*(s+1)*(2*s+1)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-20 20 -5 5])\n", +"('We see from the locus that the point -1+j0 is encircled twice,hence N=2 and P=0.')\n", +"printf('Therefore Z=2,hence two zeros lie in RHP') // N=P-Z\n", +"printf('System is unstable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.5: nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms K a\n", +"H=syslin('c',(K*(s+a))/(s*(s-1)))\n", +"// for K>1\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-5 5 -5 5])\n", +"xtitle('For K>1')\n", +"printf('P=1(pole in RHP))\n", +"printf('Nyquist plot encircles the the point -1+j0 once anti-clockwise i.e.,N=1')\n", +"printf('Hence Z=0') // N=P-Z\n", +"printf('System is stable')\n", +"// for K<1\n", +"H=syslin('c',(-2*(s+1))/(s*(s-1)))\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-5 5 -5 5])\n", +"xtitle('For K<1')\n", +"printf('The point -1+j0 lie beyond -K(the crossing point of the plot).So N=-1,P=1')\n", +"printf('Hence Z=2,zeros in RHP=2')\n", +"printf('System is unstable')\n", +"" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.6: stability_using_nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',(k*(s-2))/(s+1)^2)\n", +"// for K/2>-1 or K>-2\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"printf('P=0(poles in RHP)')\n", +"printf('N=-1,hence Z=1')\n", +"printf('Therefore,System is unstable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.7_a: stability_using_nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"s=%s;\n", +"syms k\n", +"H=syslin('c',(K*(s+2))/(s^2*(s+1)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-20 20 -20 20])\n", +"printf('P=0 and the locus does not encircle the point -1+j0')\n", +"printf('System is stable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.7_b: stability_using_nyquist_plot.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"H=syslin('c',k/(s*(s^2+s+4)))\n", +"nyquist(H)\n", +"show_margins(H,'nyquist')\n", +"mtlb_axis([-5 5 -5 5])\n", +"// nyquist plot crosses the axis of reals with intercept of -k/4\n", +"// for k/4>1 or k>4\n", +"printf('N=-2 as it encircles the point twice in clockwise direction')\n", +"printf('P=0 and hence Z=2')\n", +"printf('System is unstable for k>4')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.8_a: nyquist_criterion.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// from the nyquist plot\n", +"N=-2; // no of encirclements\n", +"P=0; // given\n", +"Z=P-N\n", +"printf('Since Z=2 therefore two roots of the characteristic equation lies in the right half of s-plane,hence the system is unstable')" + ] + } +, +{ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 9.8_b: nyquist_criterion.sce" + ] + }, + { +"cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], +"source": [ +"// from the nyquist plot\n", +"N=0; // one clockwise and one anticlockwise encirclement\n", +"P=0; // given\n", +"Z=N-P\n", +"printf('Since Z=0 no root of the characterisic equation lies in the right half hence the system is stable')" + ] + } +], +"metadata": { + "kernelspec": { + "display_name": "Scilab", + "language": "scilab", + "name": "scilab" + }, + "language_info": { + "file_extension": ".sce", + "help_links": [ + { + "text": "MetaKernel Magics", + "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" + } + ], + "mimetype": "text/x-octave", + "name": "scilab", + "version": "0.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} |