Category Archives: Program

Last updated by at .

Belajar Scilab: analisa root locus — aplikasi

Isi materi ini ditujukan untuk berbagi ilmu pengetahuan kepada semua pengunjung blog ini.
Silakan digunakan untuk kepentingan proses pembelajaran untuk mencerdaskan bangsa ini dengan tidak lupa menyebutkan sumbernya.
Namun yang harus dihindari adalah: mengambil isi dengan mengakui sebagai haknya, mengambil isi untuk tujuan komersialisasi.
Semua tergantung kepada hati-nurani, jika terjadi saya berkewajiban mengingatkan para plagiator. Biasakan sesuatunya terlahir dari tangan anda, itu menunjukkan bahwa anda ada dan anda diberi hidayah sebagai ciptaanNya yang paling mulia untuk memberikan manfaat di dunia ini. Biasakanlah memberikan manfaat kepada orang lain, dan jangan membiasakan memanfaatkan orang lain.

Dari teori analisa root locus yang telah saya posting disini, akan diaplikasikan dengan menggunakan tool scilab. Fungsi-fungsi yang akan digunakan dalam analisa root locus ini adalah:

  • deff (‘[s1,s2,...]=newfunction(e1,e2,….)’,text [,opt])
    merupakan perintah untuk mendefinisikan fungsi yang berisi variabel keluaran s1, s2 ….., nama fungsi yang digunakan dan text adalah string yang berisi perintah-perintah perhitungan.
  • roots (p)
    merupakan perintah untuk mencari akar-akar fungsi polinomial.

Testing

Misal ada persamaan polinomial variabel s:

Untuk mencari akar-akar persamaan polinomial adalah:

-->s=%s   // cara singkat mendefinisikan s sebagai variabel polinomial
 s  =

    s   

-->P=s^3+0.5*s^2+-3*s+50    // mendefinisikan persamaan polinomial
 P  =

                  2   3
    50 - 3s + 0.5s + s   

-->akar=roots(P);    // mencari akar-akarnya simpan di variabel akar

-->akar        // tampilkan
 akar  =

  - 4.1407193
    1.8203597 + 2.959981i
    1.8203597 - 2.959981i  

 Mendefinisakan fungsi

Jika persamaan polinomial diatas mengandung variabel K pada orde 2. Untuk selanjutnya K akan disetel dengan nilai-nilai yang diinginkan, maka diperlukan perintah deff. Sebagai contoh fungsi polinomial diubah menjadi:

Akar-akar akan dicari dengan menyetel K=2, 5, 8, 9. Cara mencarinya adalah:

-->s=%s
 s  =

    s   

-->deff('[tf]=tfunc(K)','tf=s^3+(K+0.5)*s^2+-3*s+50')

-->tf=tfunc(0)              // testing melihat fungsi dengan K=0
 tf  =

                  2   3
    50 - 3s + 0.5s + s     

-->roots(tf)               // testing untuk mencari akar-akarnya
 ans  =

  - 4.1407193
    1.8203597 + 2.959981i
    1.8203597 - 2.959981i  

-->roots(tfunc(2))        // cara singkat mencari akar dengan K = 2
 ans  =

  - 5.0524566
    1.2762283 + 2.8753117i
    1.2762283 - 2.8753117i  

-->roots(tfunc(5))            // mencari akar dengan K = 5
 ans  =

  - 6.9623596
    0.7311798 + 2.5781485i
    0.7311798 - 2.5781485i  

-->roots(tfunc(8))           // mencari akar dengan K = 8
 ans  =

  - 9.3870227
    0.4435114 + 2.2649062i
    0.4435114 - 2.2649062i  

-->roots(tfunc(9))          // mencari akar dengan K = 9
 ans  =

  - 10.266581
    0.3832907 + 2.1733059i
    0.3832907 - 2.1733059i  

 

Contoh aplikasi

Berikut ini sistem kontrol loop tertutup secara diagram blok digambarkan sebagai berikut:

Selesaikan blok diagram diatas:

  1. Temukan fungsi alih loop terbuka C(s)/R(s).
  2. Carilah akar-akarnya untuk setelan Kd = 0, 1, 1.5, 1.8,2, 2.5, 2.6, 2.7, 2.8, 2.9, 3, 3.1, 3.6, 4, 5, 10.
  3. Tentukan berapa nilai Kd agar sistem menjadi stabil.

Untuk menyelesaikan loop tertutup dari blok diagram diatas dikerjakan terlebih dahulu dimana:

Kemudian jika digambarkan kembali sistem secara diagram blok akan diperoleh:

 Terakhir akan diperoleh fungsi alih open loopnya menjadi:

 Jadi fungsi alih secara keseluruhan atau fungsi alih loop terbuka menjadi:

Selanjutnya dengan menggunakan scilab melalui console, akan dicari akar-akarnya untuk setiap penyetelan K agar  sistem menjadi stabil.

-->deff('[F]=fungsi_alih(Kd)','F=s^2+(Kd+2)*s+4.0')

-->roots(fungsi_alih(0))         // akar Kd = 0 -- tidak stabil
 ans  =

  - 1. + 1.7320508i
  - 1. - 1.7320508i  

-->roots(fungsi_alih(1))        // akar Kd = 1 -- tidak stabil
 ans  =

  - 1.5 + 1.3228757i
  - 1.5 - 1.3228757i  

-->roots(fungsi_alih(1.5))      // akar Kd = 1.5 -- tidak stabil
 ans  =

  - 1.75 + 0.9682458i
  - 1.75 - 0.9682458i  

-->roots(fungsi_alih(1.8))      // akar Kd = 1.8 -- tidak stabil
 ans  =

  - 1.9 + 0.6244998i
  - 1.9 - 0.6244998i  

-->roots(fungsi_alih(2))        // akar Kd = 2 -- stabil
 ans  =

  - 2.
  - 2.  

-->roots(fungsi_alih(2.5))     // akar Kd = 2.5 -- stabil
 ans  =

  - 3.2807764
  - 1.2192236  

-->roots(fungsi_alih(2.6))     // akar Kd = 2.6 -- stabil
 ans  =

  - 3.4357817
  - 1.1642183  

-->roots(fungsi_alih(2.7))     // akar Kd = 2.7 -- stabil
 ans  =

  - 3.5838963
  - 1.1161037  

-->roots(fungsi_alih(2.8))     // akar Kd = 2.8 -- stabil
 ans  =

  - 3.7266499
  - 1.0733501  

-->roots(fungsi_alih(2.9))     // akar Kd = 2.9 -- stabil
 ans  =

  - 3.8650972
  - 1.0349028  

-->roots(fungsi_alih(3))      // akar Kd = 3 -- stabil
 ans  =

  - 4.
  - 1.  

-->roots(fungsi_alih(3.1))    // akar Kd = 3.1 -- mulai tidak stabil
 ans  =

  - 4.1319292
  - 0.9680708  

-->roots(fungsi_alih(3.6))    // akar Kd = 3.6 -- tidak stabil
 ans  =

  - 4.7595918
  - 0.8404082  

-->roots(fungsi_alih(4))      // akar Kd = 4 -- tidak stabil
 ans  =

  - 5.236068
  - 0.7639320  

-->roots(fungsi_alih(5))      // akar Kd = 5 -- tidak stabil
 ans  =

  - 6.3722813
  - 0.6277187  

-->roots(fungsi_alih(10))     // akar Kd = 10 -- tidak stabil
 ans  =

  - 11.656854
  - 0.3431458  

Jadi daerah stabil paling tidak sudah ditemukan Kd berada antara 2 sampai 3. Untuk daerah yang lain bisa dicoba dengan nilai Kd lebih diperbesar, atau coba dengan nilai Kd menjadi negatip.

Untuk lebih meyakinkan diuji respon keluaran dengan memilih Kd yaitu: 0, 2, 3 dan 10, dengan menggunakan perintah scilab dalam console:

-->s=%s
 s  =

    s   

-->deff('[F]=fungsi_alih(Kd)','F=3.0/(s^2+(Kd+2)*s+4.0)')

-->t=0:0.01:15;

-->TF_0=fungsi_alih(0)
 TF_0  =

        3
    ---------
              2
    4 + 2s + s   

-->TF_2=fungsi_alih(2)
 TF_2  =

        3
    ---------
              2
    4 + 4s + s   

-->RESPON_3=csim('step',t,TF_3);

-->clear all

-->deff('[F]=fungsi_alih(Kd)','F=3.0/(s^2+(Kd+2)*s+4.0)')

-->t=0:0.01:15;

-->TF_0=fungsi_alih(0)
 TF_0  =

        3
    ---------
              2
    4 + 2s + s   

-->TF_2=fungsi_alih(2)
 TF_2  =

        3
    ---------
              2
    4 + 4s + s   

-->TF_3=fungsi_alih(3)
 TF_3  =

        3
    ---------
              2
    4 + 5s + s   

-->TF_10=fungsi_alih(10)
 TF_10  =

         3
    -----------
               2
    4 + 12s + s   

-->RESPON_0=csim('step',t,TF_0);

-->RESPON_2=csim('step',t,TF_2);

-->RESPON_3=csim('step',t,TF_3);

-->RESPON_10=csim('step',t,TF_10);

-->plot2d(t,RESPON_0,style=1)

-->plot2d(t,RESPON_2,style=3)

-->plot2d(t,RESPON_3,style=5)

-->plot2d(t,RESPON_10,style=8)

-->xgrid(4)

-->xtitle('Respon Kontroler dengan analisis root locus -
              Bambang Siswoyo - TEUB','detik','amplitudo');

-->legend(["Kd = 0"; "Kd = 2"; "Kd = 3"; "Kd = 10"],4);

 Hasil grafiknya sebagai berikut:

 

Kesimpulan

  • Dari grafik diatas untuk Kd=0, 2, 3 dan 10, membuktikan bahwa teori root locus membantu untuk medisain secara awal dengan menyetel parameter-parameter yang diinginkan.
  • Kd=0, menujukkan grafik berosilasi karena ada akar komplek, sedangkan akar real berada dikiri -1, sistem masih bisa menuju kestabilan.
  • Kd=2, menunjukkan respon yang paling stabil, karena akar semuanya real dan berada paling jauh dikir -1 jika dibandingkan dengan yang lainnya.
  • Kd=3, menunjukkan sistem bisa stabil walaupun sedikit teredam karena mendekati -1
  • Kd=10, menunjukkan sistem bisa stabil walaupun paling teredam jika dibandingkan dengan yang lainnya.
  • Semuanya berada pada amplitudo steady state sekitar 0.75, sehingga errornya masih sangat besar yaitu 0.25, atau 25%.
  • Untuk membuat sistem memiliki error yang kecil perlu didisain ulang dengan menambah penguatan pada untai G(s), misalnya dengan penguatan 10. Disain ulang sistem tersebut, dibahas di posting ini.

 

 

 

Posted in Program, scilab, Sistem Kontrol | Tagged , | 1 Comment

Scilab code: transfer function and performance of control systems using DC Motor Model

This post contains the simple code written for Scilab, associated with the modeling of permanent magnet dc motor. The code of this program are made by me and is for all who need it. So is open source, you can modify as appropriate. Do not forget you also include my name and my website link in your application or website, and do not forget me say thank you.

Source Code 1

Download

 DC motor used is a permanent magnet, with the default parameters are:

  1. Moment of inertia of the rotor: 
  2. Electromotive force constant:  
  3. Damping ratio of the mechanical system:
  4. Electric resistance:
  5. Electric inductance: 

If you want another dc motor parameters, please edit that variable in the source program.  Enter the parameters of the control constants Kp, Ki, and Ki, then the dc motor transfer function and the total transfer function of each controller P,  PI, PD and PID will be displayed.

Also, the graphics performance of the control system for each controllers P, PI, PD and PID will be generated.

 

 

Posted in Program | Tagged , , | Leave a comment