Category Archives: scilab

Berhubungan dengan program Scilab

Last updated by at .

Pengaruh fungsi alih pada sensor sebagai umpan balik

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.

Dalam sistem kontrol closed loop, peranan sensor sangat penting, karena digunakan sebagai umpan balik bagi kontroler digunakan untuk memutuskan berapa besarnya sinyal yang akan diberikan ke aktuator. Idealnya sebuah sensor sebagai umpan balik adalah memberikan informasi sesuai yang ada pada keluaran plant, atau dalam sistem blok memiliki konstanta 1, yaitu informasi berupa sinyal dari plant dikuatkan dengan nilai 1 sehingga sesuai dengan informasi yang sebenarnya. Dengan demikian kontroler sebagai penentu keputusan tidak akan salah menafsirkan berapa seharusnya besaran sinyal yang harus dikeluarkan ke masukan aktuator, sehingga sistem akan cepat menjadi stabil. Selain itu yang tidak kalah pentingnya sebuah sensor harus memiliki linieritas, artinya keluaran sensor harus proporsional dengan masukan sensor.

Pada kenyataannya sensor yang memiliki lineritas yang tinggi, sangatlah sulit untuk diwujudkan. Disini akan diuji sistem yang telah diposting disini, dengan mengganti fungsi alih dari umpan balik.

Sistem digambarkan kembali sebagai berikut:

Besarnya Kp, Ki dan Kd tetap dipertahankan seperti sebelumya yaitu berturut-turut: 300, 300 dan 30.

Sebelumnya dicari dahulu fungsi alih untai penguatan G(s) dengan menggunakan scilab agar dapat digunakan secara berulang-ulang:

-->clear all

-->Kp=300;Ki=200;Kd=30;

-->G=(Kp+1/(Ki*s)+Kd*s)*3*(1/((s+1)^2+(2*s)))
 G  =

                        2
    3 + 180000s + 18000s
    --------------------
                2      3
     200s + 800s + 200s    

-->t=0:0.1:7;

Selanjutnya akan diuji dengan menggunakan fungsi alih H(s) selain 1.

H(s) real lebih kecil dari 1

Sebagai contoh H(s) = 0.5, dengan menggunakan scilab dengan perintah berikut:

-->H1=0.5
 H1  =

    0.5  

-->TF1=G/(1+G*H1)
 TF1  =

                                  2
      0.0147960 + 899.99998s + 90s
    --------------------------------
                                2   3
    0.0073978 + 450.99999s + 49s + s   

-->RES_PID1=csim('step',t,TF1);

-->plot2d(t,RES_PID1,style=5);

-->xgrid();

Hasil responnya diperlihatkan sebagai berikut:

Dari respon dengan fungsi step, seperti diatas terlihat bahwa keluaran stabil sebesar dua kali dari setpointnya, yaitu sebesar 2. Hal ini dikarenakan sensor tidak memberikan informasi yang benar dari keluaran plant. Sensor memberikan sinyal keluaran setengah dari keluaran plant sesungguhnya, sehingga seharusnya stabil pada keluaran = 1, kontroler masih menerima error.

H(s) real lebih besar dari 1

Sebagai contoh H(s) = 1.5, dengan menggunakan scilab dengan perintah berikut:

-->H2=1.5
 H2  =

    1.5  

-->TF2=G/(1+G*H2)
 TF2  =

         899.99852 + 90s
    -------------------------
                              2
    1350.9977 + 138.99998s + s   

-->RES_PID2=csim('step',t,TF2);

-->plot2d(t,RES_PID2,style=5);

-->xgrid();

Hasil responnya diperlihatkan sebagai berikut:

Dari respon dengan fungsi step, seperti diatas terlihat bahwa keluaran stabil sebesar 0.667 kali dari setpointnya yaitu sekitar 0.667. Hal ini dikarenakan sensor memberikan penguatan  dari informasi yang benar dari keluaran plant. Sensor memberikan penguatan sinyal keluaran 1.5 kali dari keluaran plant sesungguhnya, sehingga seharusnya belum stabil pada keluaran = 1, kontroler sudah tidak menerima error. Hal ini terlihat bahwa keluaran teredam sehingga terlihat steady pada error yang besar.

H(s) mengandung delay

Sebagai contoh H(s) = 5s, dengan menggunakan scilab dengan perintah berikut:

-->H3=5*s
 H3  =

    5s   

-->TF3=G/(1+G*H3)
 TF3  =

                                       2
    0.0000333 + 1.9955654s + 0.1995565s
    -----------------------------------
                               2   3
        0.0023836s + 9.9866962s + s       

-->RES_PID3=csim('step',t,TF3);

-->plot2d(t,RES_PID3,style=5);

-->plot2d(t,RES_PID3,style=5);

-->xgrid()

Hasil responnya diperlihatkan sebagai berikut:

Dari respon dengan fungsi step, seperti diatas terlihat bahwa keluaran tidak akan pernah stabil, karena selalu menaik.  Hal ini dikarenakan sensor memberikan informasi yang terlambat terhadap keluaran plant, karena mengandung unsur diferensiator.

H(s) mengandung integrator

Sebagai contoh H(s) = 1/(0.05s), dengan menggunakan scilab dengan perintah berikut:

-->H4=1/(0.05*s)
 H4  =
 
      1     
    -----   
    0.05s   
 
-->TF4=G/(1+G*H4)
 TF4  =
 
                              2              
               899.9985s + 90s               
    -------------------------------------    
                                      2   3  
    17999.97 + 1800.9999s + 3.9999833s + s   
 
-->RES_PID4=csim('step',t,TF4);
 
-->plot2d(t,RES_PID4,style=5);
 
-->xgrid()

Hasil responnya diperlihatkan sebagai berikut:

Dari respon dengan fungsi step, seperti diatas terlihat bahwa keluaran tidak akan pernah stabil, karena menjadi berosilasi semakin membesar. Hal ini dikarenakan sensor memberikan informasi semakin menaik atau berlebihan terhadap keluaran plant, karena mengandung unsur integrator. Sistem yang demikian harus dihindari karena akan merusak plant, terutama plant mekanik.

Posted in scilab, Sistem Kontrol, Teori | Tagged , | Leave a comment

Belajar Scilab: menambahkan kontroler PID dalam untai G(s)

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.

Dalam posting ini, error telah diperbaiki dengan menambahkan penguatan dalam untai G(s), jadi sama dengan ditambahkan kontroler P. Namun dari unjuk kerja keluaran sistem masih terjadi osilasi dengan overshoot yang cukup besar sekitar 75%.

Disini akan dicoba untuk menambahkan kontroler PID didalam untai G(s). Berikut ini blok diagram dalam posting ini, digambarkan kembali:

Setelan Kd tetap dipertahankan sama dengan 2. Demikian juga nilai penguatan 3 tetap dipertahankan juga. Hanya ditambahkan Kontroler PID dalam untai G(s).

Dengan demikian sistemnya akan berubah menjadi:

Dengan menggunakan scilab dalam console, fungsi alih dan respon keluarannya dihitung untuk melihat paramater kestabilan.

-->clear all

-->t=0:0.01:1;

-->Kp=300;Ki=200;Kd=30;

-->PID=Kp+Ki/s+Kd*s
 PID  =

                    2
    200 + 300s + 30s
    ----------------
           s           

-->G=3/((s+1)^2+2*s)
 G  =

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

-->Gt=PID*G
 Gt  =

                    2
    600 + 900s + 90s
    ----------------
             2   3
       s + 4s + s      

-->TF=Gt/(1+Gt)
 TF  =

                      2
      600 + 900s + 90s
    --------------------
                    2   3
    600 + 901s + 94s + s   

-->RES_PID=csim('step',t,TF);

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

-->xgrid()

-->xtitle('Perbaikan respon dengan menambah kontroler PID dalam untai G(s) -
           Bambang Siswoyo - TEUB','detik','amplitudo');

-->legend('Kp = 300 - Ki = 200 - Kd = 30',4);

Dengan menyetel Kd=300, Ki=200 dan Kd=30, hasil perintah diatas berupa  respon keluaran  adalah:

Sebagai perbandingan antara sebelum dan sesudah ditambahkan kontroler PID diperlihatkan dalam grafik respon keluaran berikut ini:

Posted in scilab, Sistem Kontrol, Teori | Tagged , | Leave a comment

Belajar Scilab: memperbaiki error dengan menambah penguatan K dalam untai G(s)

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.

Pembahasan dalam posting sebelumnya, telah dibahas bagaimana menganalisa sistem kontrol dengan mengambarkan  penempatan akar dari polinomial pole/denumerator dari fungsi alih secara keseluruhan dengan menyetel besarnya K. Pembahasan dalam posting sebelumnya,diperoleh besaran K=2 agar diperoleh unjuk kerja yang terbaik. Namun dari hasil uji unjuk kerja respon keluaran masih memiliki error sebesar 25%, dengan time steady state sebesar kira-kira 5detik. Untuk lebih jelasnya klik disini untuk melihat respon keluaran dalam posting sebelumnya.

Lebih mudahnya digambarkan kembali diagram blok sistem tersebut.

Respon yang paling baik adalah dengan menset Kd= 2, selanjutnya akan ditambah penguatannya didalam untai G(s) dengan mengganti blok yang mengandung penguatan 3.0 dengan parameter K.

Maka fungsi alihnya secara loop terbuka akan menjadi:

Jadi fungsi alih open loopnya adalah:

Kemudian K akan disetel dengan faktor perkalian 3.0 (penguatan sebelumnya=3.0), sehingga K diganti dengan 3.K,  fungsi alihnya diubah menjadi:

Sekarang K akan disetel  dengan nilai 1, 5,  dan 100, dengan menggunakan scilab sebagai berikut:

-->clear all

-->s=%s
 s  =

    s   

-->deff('[TF]=tfunc(K)','TF=(3*K)/(s^2+4*s+3*K+1)')

-->t=0:0.01:15;

-->TF_1=tfunc(1)
 TF_1  =

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

-->TF_5=tfunc(5)
 TF_5  =

        15
    ----------
               2
    16 + 4s + s   

-->TF_100=tfunc(100)
 TF_100  =

        300
    -----------
                2
    301 + 4s + s   

-->RESP_1=csim('step',t,TF_1);

-->RESP_5=csim('step',t,TF_5);

-->RESP_100=csim('step',t,TF_100);

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

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

-->plot2d(t,RESP_100,style=6)

-->xgrid(2)

-->legend(['K = 1 : belum ditambah penguatan';'K = 5';'K = 100'],4); 

-->xtitle('Perbaikan error dengan menambah penguatan dalam untai G(s) -
              Bambang Siswoyo - TEUB','detik','amplitudo');

 Setelah diuji repon keluarannya menjadi:

Kesimpulan

  • Setelah ditambahkan penguatan dalam untai G(s) error semakin mengecil.
  • Time steady state, semakin cepat, K=5 menjadi 3 detik, K=100 menjadi 3 detik dari sekitar 5 detik dengan K=1.
  • Error paling kecil mendekai nol dengan setelan K=100.
  • Sistem masih mengalami osilasi, dan overshoot hampir 70%, perlu diperbaiki ulang dengan menambahkan kontroler PID.

 

Posted in scilab, Sistem Kontrol, Teori | Tagged , | Leave a comment

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

Belajar Scilab: analisa root locus — teori

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.

Dalam rekayasa sistem kontrol biasanya memiliki satu atau lebih parameter disain, penyesuaian atau pengaturan oleh pengguna. Hal ini sangatlah penting untuk menentukan apakah sistem yang dibuat menjadi tidak stabil. Dalam rekayasa sistem kontrol secara umum haruslah menjadi stabil agar sistem menjadi aman. Sebagai contoh, memikirkan agar mesin cuci menjadi stabil sehingga tidak membuat berjalan di lantai yang akan membuat berbahaya bagi penggunanya. Atau pesawat udara berkecepatan tinggi yang gagal tinggal landas karena getaran resonansi. Dengan penggambaran root locus (penempatan akar) dapat digunakan untuk merencanakan kestabilan sistem dengan menyetel variabel pada rentang tertentu, sehingga dapat diketahui sistem apakah menjadi tidak stabil atau berosilasi.

Dengan menelaah kembali tentang penyelesaian umum sebuah persamaan diferensial homogen, akar komplek akan menghasilkan osilasi secara sinusoida. Jika akarnya real akan menghasilkan suku-suku et. Jika akarnya adalah negatip nyata akan cenderung menurun menjadi 0 dan stabil, selain itu jika positip akan menghasilkan kenaikan secara eksponensial dan menjadi tidak stabil. Mengenai akar-akar dalam persamaan diferensial homogen orde dua, ditunjukkan dalam gambar berikut.

Perilaku unjuk kerja sistem ditentukan oleh posisi akar-akar dari penyebut atau pole pada salib sumbu komplek. Berikut ini dijelaskan hubungan unjuk kerja sistem dengan posisi akar-akar pole dari fungsi alih secara keseluruhan:

Negatip Real

Jika akar-akar polenya berupa akar negatip real, maka kerja sistem akan stabil karena cenderung menurun menuju nol.

Komplek (real = 0)


Dengan akar imajiner, maka unjuk kerja keluarannya akan menjadi sinusoida. Dengan demikian keluarannya tidak akan pernah stabil.

Negatip Real dan Komplek

Jika akar-akarnya berupa negatip real dan imajiner, biasanya berpasangan, maka unjuk kerja keluaran akan berosilasi namun semakin mengecil menuju nol. Sehingga kemungkinan sistem akan bisa menjadi stabil. Namun pada beberapa plant dihindari adanya osilasi, biasanya pada mekanik-mekanik yang besar dan berat sehingga tidak membahayakan.

Sangat negatip real dan Komplek

Dengan akar sangat negatip dan komplek osilasinya lebih kecil dan sedikit dibandingkan dengan yang diatas, sehingga akan cepat stabil.

Negatip real kembar

Kemungkinan akar-akarnya bisa negatip real namun sama atau kembar. Unjuk kerja keluarannya akan sama dengan yang sebelumnya yaitu cenderung menuju kestabilan.

Positip real kembar

Pada kondisi akar positip real kembar, unjuk kerja keluran cenderung menaik sehingga membuat sistem tidak akan pernah mencapai kestabilan.

Positip real komplek

Dengan akar positip real komplek, menjadikan unjuk keluarannya berosilasi semakin membesar. Ini harus dihindari karena akan membuat plant berbahaya.

Kesimpulan

Dengan melihat kembali solusi umum untuk suatu persamaan diferensial homogen. Akar komplek akan menghasilkan osilasi sinusoidal. Jika akar adalah nyata hasilnya akan sesuai dengan et. Jika akar-akar real negatif maka keluaran  akan cenderung meluruh sampai nol dan menjadi stabil,  sementara akar positif akan menghasilkan hal yang menaik  secara eksponensial dan menjadi tidak stabil.

Posted in scilab, Sistem Kontrol, Teori | Tagged , | 2 Comments

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

Root Locus Analysis

Referensi ini sangat berguna untuk belajar mengenai sistem kontrol guna menganalisa sistem menggunakan root locus. Root locus masih sering digunakan untuk menganalisa kestabilan dengan melihat penempatan akar-akar dari pole dan zero.

Download

Posted in Ebook Scilab, Sistem Kontrol, Teori | Tagged , | 2 Comments

Belajar Scilab: metode design PID untuk kontrol kecepatan Motor DC

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.

Berdasarkan posting disini, yang membahas tentang pemodelan motor dc magnet permanen, disini akan diaplikasikan sebuah motor dc dengan parameter motor yang sama kedalam sistem kontrol kecepatan (speed control).

Motor dc akan diaplikasikan sebagai kontrol kecepatan dengan menerapkan kontroler P, PI, PD, dan PID.Penjelasan hanya mengulas bagaimana untuk mendapatkan fungsi alih secara keseluruhan setelah plant ditambahkan kontroler dengan unity feedback.

Untuk mendapatkan fungsi alih  digunakan scilab dihitung secara manual melalui console, dengan tujuan untuk lebih memahami cara kerja perhitungan. Disini sekedar diuji unjuk kerja sistem dengan berbagai parameter Kp, Kd dan Ki, bukan mendisain sistem kontrol dengan menentukan parameter unjuk kerja terlebih dahulu. Adapun motor dc magnet permanen yang digunakan memiliki paramater yang sama dengan posting sebelumnya adalah:

  • Momen inersia motor adalah
  • Rasio redaman dari sistem mekanik
  • Konstanta electromotive force
  • Resistansi elektrik
  • Induktansi elektrik
  • Masukan (V): sumber tegangan dc
  • Keluaran posisi poros motor
  • Rotor dan poros motor diasumsikan kaku

 

1. Menentukan Fungsi alih motor dc magnet permanen

Untuk mendisain sistem kontrol kecepatan menggunakan motor dc, terlebih dahulu harus menentukan fungsi alih motor dc dengan menggunakan parameter-parameter mekanik-elektrik dari motor dc tersebut. Dapat digunakan model matematika, atau dengan menggunakan identifikasi sistem.

Fungsi alih dari motor dc tersebut jika dituliskan kembali dari posting sebelumnya adalah:

 

 Dengan menggunakan scilab akan dicari fungsi alihnya:

-->// memasukan parameter motor J,b,K,L,R
J=0.01
 J  =

    0.01  

-->b=0.1
 b  =

    0.1  

-->R=1
 R  =

    1.  

-->L=.5
 L  =

    0.5  

-->K=0.01
 K  =

    0.01  

// zero
-->num=K
 num  =

    0.01  

// mendefinisikan polinomial s
-->s=%s
 s  =

    s   

// pole
-->denum=(J*s+b)*(L*s+R)+K^2
 denum  =

                           2
    0.1001 + 0.06s + 0.005s   

// fungsi alih
-->tf=syslin('c',num,denum)
 tf  =

             0.01
    ----------------------
                           2
    0.1001 + 0.06s + 0.005s   

 

Dari hasil perhitungan dengan menggunakan console scilab seperti diatas diperoleh fungsi alih motor dc, masukan tegangan (V) dan keluaran kecepatan rotasi dalam radian/detik, sebagai berikut:

2. Menguji respon open loop

Selanjutnya diuji unjuk kerja hubungan antara tegangan masukan motor dc dan kecepatan putar dalam radian/detik, untuk pertama kalinya untuk keperluan simulasi tegangan masukan diberikan sebesar 1V berupa fungsi step. Pengujian ini adalah pengujian respon waktu secara open loop. Dalam simulasi menggunakan nilai sebesar 1, dipakai sebagai perunit dalam sistem. Berikut ini perintah untuk menganalisa unjuk kerja motor dengan menggunakan console scilab.

-->t=0:.01:4;      // waktu uji

-->res=csim('step',t,tf);   // uji respon

-->plot(t,res)    // grafik respon

-->xgrid(4)      // gambarkan grid

Grafik responnya sebagai berikut:

Dari hasil analisa motor dc dengan tegangan masukan 1V memiliki respon: kecepatan maksimum adalah 1 radian/s tercapai pada sekitar 3 detik. Jadi dalam sistem kontrol kecepatan dalam simulasi ini, motor dc ini akan diberi tegangan antara 0-1V, kecepatan maksimal keluaran adalah  rpm atau dibulatkan saja menjadi 94 rpm.

3. Menentukan fungsi alih Sensor kecepatan

Biasanya sebagai sensor kecepatan digunakan motor dc sebagai sensor kecepatan secara konvensional. Sensor ini kadang disebut dengan sensor dinamometer, dengan prinsip kebalikan dari motor yaitu masukan kecepatan putar dan keluaran adalah tegangan dc. Jika digunakan dinamometer, harus ditentukan terlebih dahulu fungsi alihnya. Namun disini menggunakan unity feedback untuk mempermudah pembelajaran, yaitu keluaran motor disambungkan secara langsung sebagai feedback atau sama dengan H(s)=1.

4. Menggambarkan Diagram blok sistem kontrol kecepatan motor dc

Agar mendapatkan dokumentasi dan lebih mudah untuk dipelajari, gambarkan secara diagram blok sistem kontrol kecepatan secara loop tertutup yang telah didisain. Secara diagram blok hasilnya diperlihatkan sebagai berikut:

5. Mencari fungsi alih secara keseluruhan

Kontroler P

Disini sebagai kontroler adalah kontroler proporsional. Misalkan konstanta penguatan kontroler Kp = 200, maka fungsi alih secara keseluruhan, dapat dipandang sebagai satu blok dan dapat diuji secara open loop. Dengan menggunakan scilab fungsi alihnya dapat diperoleh dengan cara:

-->s=%s;        // mendefinisikan polinomial s

-->tf_motor=syslin('c',0.01,0.1001+0.06*s+0.005*s^2)   // fungsi alih motor
 tf_motor  =

             0.01
    ----------------------
                           2
    0.1001 + 0.06s + 0.005s   

-->Kp=200;       // konstanta Kp

-->G_P=Kp*tf_motor      // mencari G total
 G_P  =

               2
    -----------------------
                           2
    0.1001 + 0.06s + 0.005s   

-->H=1       // unity feedback
 H  =

    1.  

-->TF_P=G_P/(1+G_P*H)      // fungsi alih total
 TF_P  =

           400
    ----------------
                    2
    420.02 + 12s + s   

 

Kontroler PI

Kontroler PI adalah:

Dimana Ki adalah konstanta penguatan integrator dan Kp adalah konstanta penguatan proporsional. Untuk mencari fungsi alih secara keseluruhan ditentukan Kp=200 , Ki =20, maka fungsi alihnya dapat dicari dengan cara:

-->Ki=20;       // konstanta Ki

-->G_PI=(Kp+Ki/s)*tf_motor     // mencari G untuk PI
 G_PI  =

           0.2 + 2s           
  ------------------------   
                 2        3  
  0.1001s + 0.06s + 0.005s   

-->TF_PI=G_PI/(1+G_PI*H)       // mencari fungsi alih total PI
 TF_PI  =
          40 + 400s          
    ---------------------    
                      2   3  
    40 + 420.02s + 12s + s  

Kontroler PD

Kontroler PD adalah:

Dimana Kd adalah konstanta penguatan diferensiator dan Kp adalah konstanta penguatan proporsional. Untuk mencari fungsi alih secara keseluruhan ditentukan Kp=300 , Kd =20, maka fungsi alihnya dapat dicari dengan cara:

-->Kp=300; Kd=20;

-->G_PD=(Kp+Kd*s)*tf_motor
 G_PD  =

           3 + 0.2s
    ----------------------
                           2
    0.1001 + 0.06s + 0.005s   

-->H=1;

-->TF_PD=G_PD/(1+G_PD*H)
 TF_PD  =

       600 + 40s
    ---------------
                    2
    620.02 + 52s + s   

Kontroler PID

Kontroler PID adalah:

Dengan menggunakan Kp=300, Ki=200 dan Kd=10, fungsi alih secara keseluruhan dengan menggunakan scilab dapat diperoleh dengan cara:

-->Kp=300; Kd=200; Ki=10;

 -->G_PID=(Kp+Ki*1/s+Kd*s)*tf_motor
 G_PID  =
 
                      2        
         2 + 3s + 0.1s         
    -----------------------    
                   2        3  
    0.1001s + 0.06s + 0.005s   

-->H=1
 H  =

    1.  

-->TF_PID=G_PID/(1+G_PID*H)
 TF_PID  =
 
                       2      
       400 + 600s + 20s       
    ----------------------    
                       2   3  
    400 + 620.02s + 32s + s       

6. Menguji unjuk kerja respon keluaran

Terakhir adalah menguji unjuk kerja sistem kontrol kecepatan motor dc untuk melihat parameter kontrolnya, terutama time steady state dan errornya. Dengan menggunakan scilab unjuk kerja keluarannya adalah sebagai berikut.

Kontroler P

Hasil uji respon kontroler P dengan Kp=200 menggunakan scilab:

Kontroler PI

Hasil uji respon kontroler PI dengan Kp=200, Ki=20 menggunakan scilab: 

Kontroler PD

Hasil uji respon kontroler P dengan Kp=300, Kd=20 menggunakan scilab:

 

Kontroler PID

Hasil uji respon kontroler PI dengan Kp=300, Ki=200, Kd=10  menggunakan scilab:

 

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

Scilab Code for Control Systems Theory and Applications

Ebook ini merupakan kumpulan-kumpulan contoh perintah dalam program scilab yang berhubungan sistem kontrol. Sangat berguna jika anda berekperimen dibidang sistem kontrol dan aplikasinya, karena banyak perintah yang harus dihapalkan.

Download

 

Posted in Ebook Scilab | Tagged , | Leave a comment

Regression analysis with scilab

Download

Posted in Ebook Scilab | Tagged , | Leave a comment

Signal Processing With Scilab

Bila anda ingin belajar bagaimana memproses sinyal dengan menggunakan program scilab open source gunakanlah buku ini sebagai acuan.

Download

Posted in Ebook Scilab | Tagged | 1 Comment

Motor DC: model state space

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.

Dalam posting sebelumnya tentang fungsi alih motor dc, diturunkan dengan menggunakan transformasi lapace diperoleh sebuah fungsi alih fungsi s. Kali ini adalah motor dc dengan model state space, kumparan medan diberi tegangan tetap atau merupakan magnet permanen. Model ini bisa digunakan dengan menggunakan pengaturan arus kumparan jangkar.

Motor dc sering diaplikasikan kedalam speed control atau servo control dengan tegangan tetap pada kumparan medan atau magnet permanen. Sebuah motor dc dengan poros dihubungkan dengan roda gila atau beban inersia, rangkaian setara elektriknya diperlihatkan dalam gambar berikut ini.

Dalam gambar diatas, dapat kita asumsikan nilai-nilai parameter yang berhubungan dengan motor tersebut. COntoh parameter-parameter berikut  diperoleh dari pengukuran:

  • Momen inersia motor adalah
  • Rasio redaman dari sistem mekanik
  • Konstanta electromotive force
  • Resistansi elektrik
  • Induktansi elektrik
  • Masukan (V): sumber tegangan dc
  • Keluaran posisi poros motor
  • Rotor dan poros motor diasumsikan kaku

Besarnya Torsi motor berhubungan dengan arus jangkar i dengan faktor konstan Kt, emf balik berhubungan langsung dengan kecepatan rotasi poros motor, secara matematika dapat dituliskan sebagai berikut:

Dalam satuan SI, Kt (konstanta jangkar), samadengan Ke (konstanta motor). Dari persamamaan diatas dapat diteulis kembali persamaannya dengan menerapkan hukum newton dan dikombinasikan dengan hukum kirchhoff.

 

Fungsi alih

Dengan menggunakan transformasi laplace dari persamaan model diatas dapat dekspresikan dengan menggunakan bentuk s:

Dengan mengeliminasi I(s), akan didapatkan fungsi alih dimana kecepatan rotasi sebagai keluaran dan tegangan sebagai masukan. Fungsi alihnya akan menjadi:

State Space

Dalam bentuk state space, persamaan diatas dapat diekpresikan dengan memilih kecepatan rotasi dan arus elektrik sebagai variabel state dan tegangan sebagai masukan. Keluaran dipilih kecepatan rotasi.

Persyaratan disain

Pertama, sebagai kompensasi motor hanya dapat berputar pada 0.1 radian/sec dengan masukan tegangan sebesar 1 Volt (akan didemontrasikan ketika respon openloop disimulasi). Persyaratan secara dasar sebuah motor harus dapat berputar sesuai dengan permintaan kecepatan, steady state error dari kecepatan motor harus lebih kecil dari 1%. Persyaratan unjuk kerja lainnya, motor harus memiliki akselerasi untuk mencapai steady state sesegera mungkin saat motor dihidupkan. Pada kasus ini diinginkan agar settling time adalah 2 detik. Jika terlalu cepat akan  peralatan, diinginkan memiliki overshoot lebih kecil dari 5%.

Jika disimulasi dengan referensi masukan sebuah masukan unit step, kecepatan keluaran motor seharusnya:

  • Settling time lebih kecil dari 2 detik
  • Overshoot lebih kecil dari 5%
  • Error steady state lebih kecil 1%

Selanjutnya respon waktu dari fungsi alih motor tersebut diatas akan diuji dengan menggunakan program scilab. Parameter-parameter yang digunakan seperti yang tertera diatas.

Fungsi Alih

-->clear all

-->s=poly(0,'s')
 s  =

    s   

-->J=0.01;

-->b=0.1;

-->K=0.01;

-->R=1;

-->L=0.5;

-->t=0:0.05:5;

-->num=K
 num  =

    0.01  

-->den=(J*s+b)*(L*s+R)+K^2
 den  =

                           2
    0.1001 + 0.06s + 0.005s   

-->h=syslin('c',num,den)
 h  =

             0.01
    ----------------------
                           2
    0.1001 + 0.06s + 0.005s  

-->r=csim('step',t,h);

-->plot (t,r)

 Hasil respon waktunya diperlihatkan dalam gambar berikut ini:

Dari plotting diatas terlihat bahwa ketika tegangan 1 Volt diberikan kepada sistem, motor hanya dapat mencapai kecepatan maksimal sekitar 0.1 radian/s. Juga motor steady state tidak dicapai dalam 3 detik, ini dibawah kriteria yang diminta dalam disain yaitu 2 detik.

Coba kita uji bagaimana jika motor diberi tegangan 220V, maka hasilnya akan menjadi:

 

State Space

-->J=0.01;

-->b=0.1;

-->K=0.01;  

-->R=1;

-->L=0.5;

-->A=[-b/J K/J; -K/L -R/L]
 A  =

  - 10.     1.
  - 0.02  - 2.  

-->B=[0; 1/L]
 B  =

    0.
    2.  

-->C=[1 0]
 C  =

    1.    0.  

-->D=0;

-->s1=syslin('domain',A,B,C,D);

-->t=0:0.05:5;

-->r=csim('step',t,s1);

-->plot (t,r)

 Hasil unjuk kerja respon waktunya sama dengan grafik diatas.

Posted in scilab, Sistem Kontrol, Teori | Tagged , | 3 Comments

Belajar Scilab: operasi matrik

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 dihidari 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.

Sebagai kelanjutan yang telah diposting disini, selanjutnya adalah bagaimana pengoperasikan matrik yang sering digunakan dalam metode komputasi.

Sebelumnya mendefinisikan data matrik orde 3×4 dengan variabel M diisi nilai acak:

-->M=rand(3,4)
 M  =

    0.0485566    0.3911574    0.4829179    0.1205996
    0.6723950    0.8300317    0.2232865    0.2855364
    0.2017173    0.5878720    0.8400886    0.8607515 

Medifinisakan matrik variabel N, orde 4×3:

-->N=[3 1 5; 3.2 3.7 6; 9 1 2; 2.3 5.6 6.5]
 N  =

    3.     1.     5.
    3.2    3.7    6.
    9.     1.     2.
    2.3    5.6    6.5  

Operasi perkalian

Perlu diingat, jumlah kolom pengali harus sama jumlah baris yang dikalikan:

-->MN=M*N
 MN  =

    6.0210139    2.6541146    4.3394607
    7.3395985    5.5658025    10.644725
    12.026868    8.0371405    11.81088

Hasil perkalian menghasilkan matrik orde 3×3 di variabel MN.

Penjumlahan Matrik

Variabel M dan MN akan dijumlahkan, namun orde M=3×4 sedangkan MN=3×3. Matrik MN yang akan dijumlahkan adalah baris 1..3 dengan menggunakan operasi M(1:3,1:3).

-->M*MN
    !--error 10
Inconsistent multiplication.

-->M
 M  =

    0.0485566    0.3911574    0.4829179    0.1205996
    0.6723950    0.8300317    0.2232865    0.2855364
    0.2017173    0.5878720    0.8400886    0.8607515  

-->M(1:3,1:3)
 ans  =

    0.0485566    0.3911574    0.4829179
    0.6723950    0.8300317    0.2232865
    0.2017173    0.5878720    0.8400886  

-->P=M(1:3,1:3)+MN
 P  =

    6.0695706    3.045272     4.8223786
    8.0119935    6.3958342    10.868011
    12.228585    8.6250125    12.650969  

Perintah pertama M*MN terdapat pesan kesalahan karena ordenya tidak cocok. Kedua melihat isi matrik M, dan ketiga melihat isi matrik M baris 1 sampai 3. Terakhir P diisi dengan hasil penjumlahan matrim M baris 1 sampai 3 dengan matrik MN.

Matrik Transpose

Untuk memperoleh matrik transpose, menggunakan matlab sangat mudah dilakukan. Berikut ini hasil matrik transpose dari matrik P disimpan dalam P1.

-->P1=P'
 P1  =

    6.0695706    8.0119935    12.228585
    3.045272     6.3958342    8.6250125
    4.8223786    10.868011    12.650969  

Matrik Inverse

Selanjutnya P2 disini dengan matrik inverse P1, perintahnya sebagai berikut:

-->P2=inv(P1)
 P2  =

    0.4988561  - 1.2270212    0.3543420
  - 0.1193309  - 0.6930515    0.5878464
  - 0.0876441    1.0631006  - 0.5610236 

Pembagian Matrik

Berikutnya pembagian matrik antara P1 dan P2, hasilnya disimpan di P3.

-->P3=P1/P2
 P3  =

    120.20925    232.77314    298.02925
    79.553624    159.04213    201.51828
    123.37358    245.63773    312.75461  

Pangkat

Berikut ini P4 diisi dengan matrik P3 dipangkat 2.

-->P4=P3^2
 P4  =

    69737.146    138209.45    175943.94
    47077.49     93312.837    118784.97
    72957.671    144609.13    184084.87  

Juga dapat dilakukan P3 dipangkat dengan sebuah operasi lainnya, seperti berikut ini.

-->P3^sin(0.7*%pi)
 ans  =

    36.58        67.906238    87.765825
    23.336135    47.486817    59.493362
    36.231832    72.66662     92.731514  

to be continue

Posted in Program open source, scilab | Tagged , , | Leave a comment

Belajar Scilab: pengantar matrik

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 dihidari 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.

Dalam scilab matrik merupakan variabel array yang memiliki jumlah baris dan kolom sesuai dengan kebutuhan. Perlakuan matrik dalam scilab sangatlah mudah. Disini akan dijelaskan dasar-dasar bagaimana memperlakukan matrik dalam scilab.

Ada beberapa cara untuk memasukkan nilai dalam variabel matrik yaitu:

  1. Pisahkan setiap elemen baris matrik dengan spasi atau koma (,)
  2. Pisahkan setiap elemen baris matrik denga karakter titik koma (;)
  3. Letakkan seluruh elemen matik dalam sepasang kurung persegi ([])

Misalkan akan memberi nilai dalam matrik persegi orde 3×3 dan dimasukkan dalam variabel M:

-->M=[2 12 3; 1 2 8; 5 16 11]
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11. 

Atau dapat anda masukkan dengan cara:

-->M=[2,12,3; 1,2,8; 5,16,11]
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

Menghitung jumlah Dalam matrik persegi mungkin ingin menghitung jumlah elemen kolom dan jumlah elemen baris dan jumlah elemen diagonal. Hal ini dapat dilakukan dengan cara:

-->sum(M,'c')
 ans  =

    17.
    11.
    32.  

-->sum(M,'r')
 ans  =

    8.    30.    22.
 

Jumlah diagonal utama, mudah dilakukan dengan menggunakan fungsi ‘diag’:

-->diag(M)
 ans  =

    2.
    2.
    11. 

Mengisi matrik dengan nilai random

-->MR=rand(3,3)
 MR  =

    0.2615761    0.5253563    0.2256303
    0.4993494    0.5376230    0.6274093
    0.2638578    0.1199926    0.7608433

-->sum(MR,'c')
 ans  =

    1.0125628
    1.6643817
    1.1446937  

-->sum(MR,'r')
 ans  =

    1.0247834    1.1829718    1.6138829  

Menambah baris matrik

Untuk menambah baris matrik yaitu dengan menambah elemen baris dengan kolom yang sama dari matrik yang akan ditambahkan. Matrik yang lama dimasukkan kembali ke elemen matrik deng ditambahkan karakter ;, karena akan menambahkan baris.

-->M
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

-->M=[M; 34 10 33]
 M  =

    2.     12.    3.
    1.     2.     8.
    5.     16.    11.
    34.    10.    33.  

Subscript

Setiap elemen dalam matrik ditandai dengan subscript nomer baris dan kolom, cara penulisannya adalah: M(b,k), dengan menuliskan nama matrik diikuti dengan , didalam kurung ().

Berikut ini salah satu contoh untuk menghitung jumlah diagonal yang lain (elemen kanan atas ke kiri bawah),  dengan  menggunakan subscript matrik:

-->M(1,3)+M(2,2)+M(3,1)
 ans  =

    10.  

Menghapus baris matrik

Untuk menghapus matrik baris terakhir yaitu dengan cara:

-->M
 M  =

    2.     12.    3.
    1.     2.     8.
    5.     16.    11.
    34.    10.    33.  

-->M=[M(1:3,1:3)]
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

Cara diatas dengan menggunakan operator semi-kolon (:) seperti yang dijelaskan dibawah.

Cara lain dimungkinkan untuk mengakses elemen dalam matrik menggunakan indek tunggal. Sekarang matrik M telah menjadi matrik orde 4×3. Sehingga M(1) = M(1,1), M(2) = M(2,1), M(3) = M(3,1), M(4) = M(4,1), M(5) = M(1,2), M(6) = M(2,2), dan seterusnya.

Sebuah cara cerdas untuk mendapatkan jumlah diagonal yang lain adalah dari matrik M, dengan menggunakan fungsi mtlb_fliplr , di mana mtlb singkatan Matlab. Berikut ini ini adalah untuk flip matriks kiri ke kanan (lr):

-->M
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

-->ML=mtlb_fliplr(M)
 ML  =

    3.     12.    2.
    8.     2.     1.
    11.    16.    5.  

-->MD=diag(ML)
 MD  =

    3.
    2.
    5.  

-->sum(MD,'r')
 ans  =

    10. 

Cara singkat dari cara diatas adalah:

-->sum(diag(mtlb_fliplr(M)))
 ans  =

    10. 

 Operator Kolon

Operator kolon (:) memegang peranan penting dalam scilab. Ekpresi 1:12 menghasilkan matrik baris dengan elemen 1,2,3,4…12.

-->1:12
 ans  =

    1.    2.    3.    4.    5.    6.    7.    8.    9.    10.    11.    12.  

Untuk menghasilkan elemen mulai 20 sampai 4 dengan petambahan nilai menurun 2, dapat dituliskan sebagai berikut:

-->20:-2:4
 ans  =

    20.    18.    16.    14.    12.    10.    8.    6.    4.  

Dengan menggunakan operator kolon inipun, dapat mengambil elemen matrik tertentu. Sebagai contoh, untuk mengambil baris kedua saja:

-->M
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

-->M(2,:)
 ans  =

    1.    2.    8. 

Berikut ini contoh untuk mengambil baris 1 dan 3 saja.

-->M([1,3],:)
 ans  =

    2.    12.    3.
    5.    16.    11.  

Contoh lagi untuk mengambil elemen acak, hasilnya menjadi matrik 1 baris.

-->[M(2,1) M(3,3) M(1,2)]
 ans  =

    1.    11.    12.  

Sama dengan diatas namun hasilnya sebagai matrik kolom.

-->[M(2,1); M(3,3); M(1,2)]
 ans  =

    1.
    11.
    12.

Operator $ adalah nilai terbesar indek matrik, ini berguna untuk mendapatkan entri terakhir dari vektor atau matrik. Berikut ini contoh untuk mengakses semua elemen kolom terakhir kecuali kolom terakhir dari baris terakhir, kita ketik:

-->M
 M  =

    2.    12.    3.
    1.    2.     8.
    5.    16.    11.  

-->M(1:$-1,$)
 ans  =

    3.
    8.  
Posted in Program open source, scilab | Tagged , , | Leave a comment

Belajar Scilab: membaca file microsoft excel (cara 3)

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 dihidari 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.

Posting yang saya tulis disini dan yang ditulis disini, merupakan cara membaca data dalam bentuk format microsoft excel dengan ektensi .xls. Selain itu microsoft excel juga dapat membaca dalam bentuk format yang berektensi .csv dari singkatan comma separated value. Format ini sebenarnya adalah format text, dimana setiap satu record data dipisahkan dengan karakter koma antara masing-masing fieldnya. Sedangkan untuk record berikutnya dituliskan di baris berikutnya atau dipisahkan dengan karakter .

Jika anda memiliki file dengan ektensi .xls, melalui microsoft excel dapat di simpan sebagai file dengan ektensi .csv, kemudian datanya dapat dibaca oleh scilab melalui cara yang akan dibahas disini. Agar dapat dibandingkan dengan posting sebelumnya, digunakan file excel yang sama seperti berikut ini.

Setelah disimpan dalam format dengan ektensi .csv, akan diperoleh file format text sebagai berikut:

0.2113249,0.5608486,0.3076091,0.5015342,0.2806498,Bambang Siswoyo,Pria
0.7560439,0.6623569,0.9329616,0.4368588,0.1280058,Ekoyanto Pudjiono,Pria
0.0002211,0.7263507,0.2146008,0.2693125,0.7783129,Nurhidayat,Pria
0.3303271,0.1985144,0.312642,0.6325745,0.211903,Ana Safitri,Wanita
0.6653811,0.5442573,0.3616361,0.4051954,0.1121355,Wijono,Pria
0.6283918,0.2320748,0.2922267,0.9184708,0.6856896,Masruri,Pria
0.8497452,0.2312237,0.5664249,0.0437334,0.1531217,Mochammad Rusli,Pria
0.685731,0.2164633,0.4826472,0.4818509,0.6970851,Ive Emaliana,Wanita
0.8782165,0.8833888,0.3321719,0.2639556,0.8415518,Ari Wahjudi,Pria
0.068374,0.6525135,0.5935095,0.4148104,0.4062025,M. Aswin,Pria

Fungsi yang akan digunakan untuk membaca file dengan format csv dalam scilab adalah:

read_csv() — write_csv()

Dengan fungsi diatas  data dapat saling dipertukarkan antara excel dan scilab sesuai dengan kebutuhan.

Berikut ini bagaimana file text dengan format csv dibaca dengan scilab:

-->-->sh=read_csv("d:/data_scilab/data1.csv")
 sh  =

!0.2113249 0.5608486 0.3076091 0.5015342  0.2806498  Bambang Siswoyo  Pria  !
!                                                                           !
!0.7560439 0.6623569 0.9329616 0.4368588  0.1280058 Ekoyanto Pudjiono Pria  !
!                                                                           !
!0.0002211 0.7263507 0.2146008 0.2693125  0.7783129 Nurhidayat        Pria  !
!                                                                           !
!0.3303271 0.1985144 0.312642  0.6325745 0.211903  Ana Safitri        Wanita!
!                                                                           !
!0.6653811 0.5442573 0.3616361 0.4051954 0.1121355 Wijono             Pria  !
!                                                                           !
!0.6283918 0.2320748 0.2922267 0.9184708 0.6856896 Masruri            Pria  !
!                                                                           !
!0.8497452 0.2312237 0.5664249 0.0437334 0.1531217 Mochammad Rusli    Pria  !
!                                                                           !
!0.685731  0.2164633 0.4826472 0.4818509 0.6970851 Ive Emaliana       Wanita!
!                                                                           !
!0.8782165 0.8833888 0.3321719 0.2639556 0.8415518 Ari Wahjudi        Pria  !
!                                                                           !
!0.068374  0.6525135 0.5935095 0.4148104 0.4062025 M. Aswin           Pria  !

Dengan perintah diatas seluruh data dalam format csv, disimpan dalam matrik divariabel sh sesuai dengan ukuran yang sama jika dibaca dengan microsoft excel.

Selanjutnya jika anda ingin menyimpannya kembali kedalam format .csv, digunakan fungsi write_csv(). Agar terdapat perubahan data, saya akan menambahkan satu data lagi dengan menggunakan scilab

Karena variabel sh adalah cell, jadi penambahan data diperlakukan sebagai cell dengan perintah berikut ini:

-->sh(11,1:7)=['0.62772' '0.92882' '0.2333' '0.827726' '0.366353'
   'Joko Suwarto Utomo' 'Pria']
 sh  =

!0.2113249 0.5608486 0.3076091 0.5015342  0.2806498  Bambang Siswoyo  Pria  !
!                                                                           !
!0.7560439 0.6623569 0.9329616 0.4368588  0.1280058 Ekoyanto Pudjiono Pria  !
!                                                                           !
!0.0002211 0.7263507 0.2146008 0.2693125  0.7783129 Nurhidayat        Pria  !
!                                                                           !
!0.3303271 0.1985144 0.312642  0.6325745 0.211903  Ana Safitri        Wanita!
!                                                                           !
!0.6653811 0.5442573 0.3616361 0.4051954 0.1121355 Wijono             Pria  !
!                                                                           !
!0.6283918 0.2320748 0.2922267 0.9184708 0.6856896 Masruri            Pria  !
!                                                                           !
!0.8497452 0.2312237 0.5664249 0.0437334 0.1531217 Mochammad Rusli    Pria  !
!                                                                           !
!0.685731  0.2164633 0.4826472 0.4818509 0.6970851 Ive Emaliana       Wanita!
!                                                                           !
!0.8782165 0.8833888 0.3321719 0.2639556 0.8415518 Ari Wahjudi        Pria  !
!                                                                           !
!0.068374  0.6525135 0.5935095 0.4148104 0.4062025 M. Aswin           Pria  !
!                                                                           !
!0.62772   0.92882   0.2333    0.827726  0.366353  Joko Suwarto Utomo Pria  !

Selanjutnya data tersebut dapat disimpan kembali kedalam format csv dengan nama file data2.csv dengan perintah sebagai berikut:

write_csv(sh, "d:/data_scilab/data2.csv", ",")

Parameter pertama adalah nama variabel dari cell (sh), kedua adalah direktori dan nama file, ketiga adalah separatornya adalah karakter koma. Setelah dibaca oleh microsoft excel akan nampak sebagai berikut:

Sekian mudah-mudahan bermanfaat.

Posted in Program open source, scilab | Tagged , , | 7 Comments

Belajar Scilab: membaca file microsoft excel (cara 2)

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 dihidari 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.

Seperti yang telah diposting disini, sekarang akan dijelaskan cara yang lainnya dengan menggunakan fungsi:

readxls()

Adapun data file microsoft excel, menggunakan file excel yang sama dengan sebelumnya agar dapat dibandingkan dengan cara sebelumnya. Data tersebut sebagai berikut:

Untuk membaca data file excel digunakan perintah sebagai berikut:

-->sheets = readxls("d:/data_scilab/data1.xls");

-->typeof(sheets)
 ans  =

 xls   

-->s1 = sheets(1);

-->s1
 s1  =

!0.2113249 0.5608486 0.3076091 0.5015342 0.2806498 Bambang Siswoyo    Pria    !
!                                                                             !
!0.7560439 0.6623569 0.9329616 0.4368588 0.1280058 Ekoyanto Pudjiono  Pria    !
!                                                                             !
!0.0002211 0.7263507 0.2146008 0.2693125 0.7783129 Nurhidayat         Pria    !
!                                                                             !
!0.3303271 0.1985144 0.312642  0.6325745 0.211903  Ana Safitri        Wanita  !
!                                                                             !
!0.6653811 0.5442573 0.3616361 0.4051954 0.1121355 Wijono             Pria    !
!                                                                             !
!0.6283918 0.2320748 0.2922267 0.9184708 0.6856896  Masruri           Pria    !
!                                                                             !
!0.8497452 0.2312237 0.5664249 0.0437334 0.1531217  Mochammad Rusli   Pria    !
!                                                                             !
!0.685731  0.2164633 0.4826472 0.4818509 0.6970851  Ive Emaliana      Wanita  !
!                                                                             !
!0.8782165 0.8833888 0.3321719 0.2639556 0.8415518  Ari Wahjudi       Pria    !
!                                                                             !
!0.068374  0.6525135 0.5935095 0.4148104 0.4062025  M. Aswin          Pria    !

-->s1.value()
 ans  =

    0.2113249    0.5608486    0.3076091    0.5015342    0.2806498    Nan   Nan
    0.7560439    0.6623569    0.9329616    0.4368588    0.1280058    Nan   Nan
    0.0002211    0.7263507    0.2146008    0.2693125    0.7783129    Nan   Nan
    0.3303271    0.1985144    0.312642     0.6325745    0.211903     Nan   Nan
    0.6653811    0.5442573    0.3616361    0.4051954    0.1121355    Nan   Nan
    0.6283918    0.2320748    0.2922267    0.9184708    0.6856896    Nan   Nan
    0.8497452    0.2312237    0.5664249    0.0437334    0.1531217    Nan   Nan
    0.685731     0.2164633    0.4826472    0.4818509    0.6970851    Nan   Nan
    0.8782165    0.8833888    0.3321719    0.2639556    0.8415518    Nan   Nan
    0.068374     0.6525135    0.5935095    0.4148104    0.4062025    Nan   Nan 

-->s1.text()
 ans  =

!          Bambang Siswoyo    Pria    !
!                                     !
!          Ekoyanto Pudjiono  Pria    !
!                                     !
!          Nurhidayat         Pria    !
!                                     !
!          Ana Safitri        Wanita  !
!                                     !
!          Wijono             Pria    !
!                                     !
!          Masruri            Pria    !
!                                     !
!          Mochammad Rusli    Pria    !
!                                     !
!          Ive Emaliana       Wanita  !
!                                     !
!          Ari Wahjudi        Pria    !
!                                     !
!          M. Aswin           Pria    !

Variabel s1 berisi yang sama dengan data dalam file excel, sesuai dengan baris dan kolomnya. s1.value() adalah isi yang mengandung nilai numeric, sedangkan s1.text yang berisi string atau text.

Jika dibandingkan dengan cara sebelumnya, cara ini lebih mudah bagi orang awam karena tidak menggunakan index. Selain itu file langsung dibuka seketika, tanpa menggunakan fungsi xls_open(). Cara ini adalah instant, namun cara sebelumnya memiliki kelebihan yaitu memiliki informasi secara detail, sehingga pengembangan program akan lebih leluasa.

Saya sarankan kalau hanya ingin mengimport data dari excel secara cepat, hanya untuk mendapatkan datanya, sebaiknya digunakan cara ini.

Sekian mudah-mudahan berguna.

 

Posted in Program open source, scilab | Tagged , , | Leave a comment

Belajar Scilab: membaca file microsoft excel (cara 1)

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 dihidari 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.

Jika anda memiliki data yang disimpan dalam microsoft excel 2003 atau sebelumnya, anda dapat mengimport data tersebut kedalam scilab untuk diolah dengan mudah melalui program atau secara immidiate di console scilab. Disini saya akan menjelaskan tentang perintah-perintah scilab dengan cara memanggil fungsi yang berhubungan dengan micrsoft excel.

Scilab menyediakan 3 cara membaca file microsoft excel. Disini dijelaskan cara pertam, dengan menggunakan fungsi:

xls_open() dan xls_read()

Misalkan anda memiliki data yang disimpan dengan microsoft excel dengan data sebagai berikut:

Data diatas merupakan data karangan saja, yang berhubungan dengan nama. Satu baris data terdiri dari 5 data numeric, 2 string. Data string berupa nama dan jenis kelamin. Data tersebut perlu diimport kedalam scilab utuk diolah datanya. misalnya diplot untuk masing-masing nama.

Dalam contoh hanya dilakukan secara immidiate kedalam console scilab.

 Membaca data excel dengan perintah xls_open() and xls_read()

Langkah-langkahnya adalah:

  1. Bukalah file excel dengan fungsi xls_open()
  2. Bacalah data dari file excel dengan fungsi xls_read()
  3. Tutup file excel dengan fungsi mclose()

 Perintah xls_open() selengkapnya adalah sebagai berikut:

[fd, vstr, nsh, psh] = xls_open(filename)

Perintah ini memiliki keluaran sebanya 4 parameter yaitu:

  1. fd : adalah file descriptor dari file yang dibuka untuk dibaca. Nama file yang disebut harus ada dalam direktori drive yang disebutkan, jika tidak ada maka akan dikeluarkan pesan kesalahan.
  2. vstr : adalah vektor seluruh string yang ada dalam sheet excel.
  3. nsh : adalah nama sheet dalam dokomen excel.
  4. psh : adalah vektor dari angka yang berisi sheet mulai dari awal dari file excel.

Cobalah perintah perikut:

-->[fd,vstr,nsh,psh]=xls_open("d:/data_scilab/data1.xls")
 psh  =

    11952.
 nsh  =

 data1
 vstr  =

         column 1 to 6

!Bambang Siswoyo  Nurhidayat  Ana Safitri  Ekoyanto Pudjiono  Wijono  Masruri  !

         column  7 to 12

!Mochammad Rusli  Ive Emaliana  Ari Wahjudi  M. Aswin  Pria  Wanita  !
 fd  =

    1.

Variabel fd berisi nilai 1, sebagai file descriptor. Variabel nsh berisi sesuai dengan nama sheet dalam dokumen microsoft excel yaitu data1. Sedangkan variabel vstr berisi vektor dari semua string yang ada, artinya jika ada string yang sama (Pria, Wanita), dalam variabel vst hanya satu saja.

Selanjutnya anda dapat memisahkan antara numeric dan string dari file yang telah dibuka tadi, dengan menggunakan perintah:

-->[numeric,string]=xls_read(fd,psh(1))

 string  =

    0.    0.    0.    0.    0.    1.     11.
    0.    0.    0.    0.    0.    4.     11.
    0.    0.    0.    0.    0.    2.     11.
    0.    0.    0.    0.    0.    3.     12.
    0.    0.    0.    0.    0.    5.     11.
    0.    0.    0.    0.    0.    6.     11.
    0.    0.    0.    0.    0.    7.     11.
    0.    0.    0.    0.    0.    8.     12.
    0.    0.    0.    0.    0.    9.     11.
    0.    0.    0.    0.    0.    10.    11.
 numeric  =

    0.2113249    0.5608486    0.3076091    0.5015342    0.2806498    Nan   Nan
    0.7560439    0.6623569    0.9329616    0.4368588    0.1280058    Nan   Nan
    0.0002211    0.7263507    0.2146008    0.2693125    0.7783129    Nan   Nan
    0.3303271    0.1985144    0.312642     0.6325745    0.211903     Nan   Nan
    0.6653811    0.5442573    0.3616361    0.4051954    0.1121355    Nan   Nan
    0.6283918    0.2320748    0.2922267    0.9184708    0.6856896    Nan   Nan
    0.8497452    0.2312237    0.5664249    0.0437334    0.1531217    Nan   Nan
    0.685731     0.2164633    0.4826472    0.4818509    0.6970851    Nan   Nan
    0.8782165    0.8833888    0.3321719    0.2639556    0.8415518    Nan   Nan
    0.068374     0.6525135    0.5935095    0.4148104    0.4062025    Nan   Nan

Perintah diatas menghasilkan dua variabel yaitu numeric (kiri) dan string (kanan). Ukuran matrik dari string dan numeric akan sama sesuai dengan ukuran data pada file excel, yaitu 7×10. Variabel numeric akan berisi data numeric, bila bukan maka diisi dengan “Nan” artinya selain numeric. Variabel string akan berisi numeric sebagai indek dari variabel vst yang berisi string.

Plotting Data

Sebagai contoh kasus adalah, bagaimana memplot data 3 nama kedalam satu window grafik. Setiap nama memiliki 5 data pada masing-masing baris yang bersesuaian. 3 nama pertama adalah “Bambang Siswoyo“, “Nurhidayat“, “Ana Safitri“. Masing-masing datanya ada di baris 1-3, kolom 1-5 dalam variabel numeric. Sedangkan indek nama ada dalam variabel string kolom 6 baris 1-3. Sedangkan data string ada dalam variabel vstr.

-->t=1:5
 t  =

    1.    2.    3.    4.    5.  

-->plot(t,numeric(1,1:5),'o-')

-->plot(t,numeric(2,1:5),'*-')

-->plot(t,numeric(3,1:5),'X-')

-->legend(vstr(string(1:3,6)))
 ans  =

 !--error 144
Undefined operation for the given operands.

check or define function %c_a_s for overloading.

at line     208 of function %h_p called by :
legend(vstr(string(1:3,6)))

 Hasil grafiknya sebagai berikut:

Selamat mencoba, semoga bermanfaat.

 

Posted in Program open source, scilab | Tagged , , | Leave a comment

Belajar Scilab: plot grafik 2D

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 dihidari 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.

Dengan menggunakan Scilab mem-plot grafik 2 dimensi dapat dilakukan dengan mudah, dengan memberikan perintah-perintah dalam scilab. Sebenarnya scilab dapat melakukan berbagai macam variasi untuk mengeplot 2D dan 3D, namun dalam posting disini dijelaskan untuk 2D.

Grafik secara umum yang dapat dilakukan oleh scilab adalah: plot xy, plot kontur, plot 3D, histogram, bar chart, dll. Biasakanlah didalam belajar scilab menggunakan perintah-perintah secara manual melalui console scilab, hal ini akan membiasakan anda untuk memperkuat ingatan tentang fasilitas-fasilitas fungsi yang ada di scilab, selanjutnya akan memperkuat didalam membuat program dalam scilab.

Jalan program scilab, gunakan console, masukkan perintah-perintah berikut ini:

-->x=linspace(0,10,21)
 x  =

         column  1 to 18

    0.    0.5    1.    1.5    2.    2.5    3.    3.5    4.    4.5    5.    5.5
    6.    6.5    7.    7.5    8.    8.5    

         column 19 to 21

    9.    9.5    10. 

Perintah diatas artinya variabel x diisi dengan deret data secara linier mulai dari 0 sampai 10 dengan 21 data. Nampak bahwa data diisi dengan mulai 0 seterusnya dengan pertambahan nilai 0.5.

--> y=linspace(0,20,21) 
  y  =          
       column  1 to 18    
   0.    1.    2.    3.    4.    5.    6.    7.    8.    9.    10.     11.   
   12.   13.    14.    15.    16.    17. 

      column 19 to 21
   18.    19.    20.     

Perintah diatas sama dengan sebelumnya, yaitu variabel y diisi dengan deret data secara linier mulai 0 sampai 20 dengan 21 data, dimulai dengan 0 seterusnya dengan pertambahan nilai 0.5.

Sampai disini sudah ada data di variable x dan y masing-masing dengan 21 data, selanjutnya data tersebut akan diplot pada salib sumbu x,y. Perintah yang digunakan dengan perintah yang tersedia di matlab, sebagai berikut:

--> plot(x,y)

Perintah tersebut akan diplot sebagai berikut:

Nampak hasilnya adalah garis linier. Sarat mutlak didalam memplot dua array data adalah jumlah data haruslah sama, jika tidak scilab akan mengeluarkan pesan kesalahan. Pesan kesalahan tersebut adalah:

-->plot(x,y)
 !--error 10000
plot: Wrong size for input arguments 'X' and 'Y': Incompatible dimensions.
at line      93 of function checkXYPair called by :
at line     233 of function plot called by :
plot(x,y)

Seperti yang anda lihat grafik anda pertama dibuka dalam window 0. Jika anda menginginkan membuka window grafik sesuai yang anda suka lakukan perintah berikut:

-->xset('window',1)

Perintah diatas seakan anda mememesan dan mengarahkan ke window grafik nomer 1. Selanjutnya perintah-perintah yang berhubungan dengan grafik, akan ditujukan ke grafik 1. Oleh scilab akan dibuatkan window grafik dengan nomer 1, namun kosong isinya. Jika perintah ini diarahkan ke nomer grafik yang telah ada windownya (misal 0), maka tidak akan dibuatkan window baru, namun perintah selanjutnya akan mengarah ke nomer window grafik yang baru disebutkan.

Selanjutnya coba perintah berikut ini:

plot2d(x,y,style=3)

Perintah khusus plot 3d, sama seperti plot(x,y), namun memiliki argumen opsional yaitu argumen ke 3 “style” yang secara langsung anda bisa memilih style yang tersedia. Hasilnya sebagai berikut ini:

 Coba sendiri untuk  argumen style dengan nilai negatip. Style ini biasanya berguna untuk memberikan tampilan yang berbeda untuk setiap grafik yang ditampilkan. Selain itu dapat ditampilkan grafik dengan nilai awal tertentu untuk x dan y, seperti perintah berikut ini.

-->plot2d(x,y,style=-4,rect=[1,4,10,10])

 Perintah diatas menggunakan 4 argumen, yang terakhir mendefinisikan nilai awal sampai akhir dari x,y grafik akan diplot. Perintah diatas grafik diplot mulai x= 1 sampai 10, dan y = 4 sampai 10. Hasilnya nampak dalam gambar berikut ini.

Sekarang akan ditunjukkan bagaimana menambahkan judul, nama axis dan legend pada grafik.

-->title("Grafik omset penjualan")

-->xlabel("Hari ke:")

-->ylabel("Jumlah dalam ribuan")

Perintah diatas untuk memberikan judul, nama axis x, nama axis y. Hasilnya akan nampak sebagai berikut.

 

 Penulisan perintah diatas dapat disingkat dengan perintah berikut ini:

-->xtitle("Grafik omset penjualan","Hari ke:","Jumlah dalam ribuan")

 Perintah langsung menggunakan 3 argumen, dimulai dengan judul, nama axis x, nama axis y. Perintah ini sangat singkat penulisannya. Untuk menghapus grafik pada window sekarang bis menggunakan clf (clear figure), disamping secara langsung  dengan cara menutup window grafik.

Selanjutnya akan ditunjukkan bagaimana menampilkan duagrif dalam satu window grafik.

Fungsi grafik pertama: , sedangkan fungsi grafik yang kedua adalah: .

Grafik akan dimunculkan y1 fungsi x, y2 fungsi x. Grafik juga akan diberi judl dan label axis x dan axis y. Perintah berikut silakan anda coba sendiri.

-->x=linspace(1,10,50);

-->y1=x^2;

-->plot(x,y1,"o-")

-->y2=2*x^2;

-->plot(x,y2,"+-")

-->xtitle("Dua Grafik dalam satu window","X axis","Y axis")

 Hasilnya diperlihatkan dalam gambar berikut:

 Style untuk fungsi menggunakan argumen “o-”, sehingga ditampilkan grafik menggunakan huruf o. Sedangkan style untuk fungsi menggunakan argumen “+-”, sehingga grafik ditampilkan dengan karakter +.

Selanjutnya akan ditunjukkan bagaimana memberikan legend pada masing-masing grafik seperti perintah berikut ini:

-->legend ( " x ^ 2 " , " 2* x ^ 2 " );

Hasilnya akan nampak sebagai berikut:

 Untuk lebih jelasnya tekan icon demo:

Kemudian pilih “Graphics” => “2D and 3D plots”.

 

Ikutilah dan amatilah setiap demo yang ditampilkan dengan menekan tombol <enter>.

 Semoga bermanfaat, selamat belajar semoga sukses.

 

Posted in Program open source, scilab | Tagged , , | 2 Comments

Belajar Scilab: tanggapan waktu fungsi alih orde dua

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 dihidari 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.

Disini saya akan menjelaskan bagaimana menggambarkan tanggapan waktu dari fungsi alih orde dua dengan menggunakan Software Scilab.

Dalam posting tentang fungsi alih orde dua, fungsi alihnya dapat dituliskan kembali sebagai berikut:

Dengan menggunakan scilab, akan digambarkan tanggapan waktu dari fungsi alih diatas dengan berbagai rasio redaman  dengan frekwensi alamiah tetap sebesar .  Besarnya dihitung mulai 0.02,  0.05, 0.3, 0.6, 0.8, 1. Sedangkan besarnya .

Listing perintah dalam console scilab sebagai berikut:

-->clear all         // membersihkan semua definisi variabel

-->s=poly(0,'s')          // mendefinisikan s sebagai variabel polynomial
 s  =

    s   

-->fn=2                   // frekwensi natural = 2Hz
 fn  =

    2.  

-->wn=2*%pi*fn            // menghitung frekwensi natural dalam rad/s
 wn  =

    12.566371  

-->// fungsi alih 1 rasio redaman = 0.02
-->h1=syslin('c',wn^2,s^2+2*0.02*wn*s+wn^2)
 h1  =

            157.91367
    -------------------------
                              2
    157.91367 + 0.5026548s + s   

-->// fungsi alih 1 rasio redaman = 0.05
-->h2=syslin('c',wn^2,s^2+2*0.05*wn*s+wn^2)
 h2  =

            157.91367
    -------------------------
                              2
    157.91367 + 1.2566371s + s   

-->// fungsi alih 1 rasio redaman = 0.3
-->h3=syslin('c',wn^2,s^2+2*0.3*wn*s+wn^2)
 h3  =

            157.91367
    -------------------------
                              2
    157.91367 + 7.5398224s + s   

-->// fungsi alih 1 rasio redaman = 0.6
-->h4=syslin('c',wn^2,s^2+2*0.6*wn*s+wn^2)
 h4  =

            157.91367
    -------------------------
                              2
    157.91367 + 15.079645s + s   

-->// fungsi alih 1 rasio redaman = 0.8
-->h5=syslin('c',wn^2,s^2+2*0.8*wn*s+wn^2)
 h5  =

            157.91367
    -------------------------
                              2
    157.91367 + 20.106193s + s   

-->// fungsi alih 1 rasio redaman = 1
-->h6=syslin('c',wn^2,s^2+2*1*wn*s+wn^2)
 h6  =

            157.91367
    -------------------------
                              2
    157.91367 + 25.132741s + s   

-->// medefinisikan t mulai 0 -- 5 detik dengan step 0.05 detik
-->t=0:0.05:5;                   

-->r1=csim('step',t,h1);   // respon waktu fungsi step fungsi alih 1

-->r2=csim('step',t,h2);   // respon waktu fungsi step fungsi alih 2

-->r3=csim('step',t,h3);   // respon waktu fungsi step fungsi alih 3

-->r4=csim('step',t,h4);   // respon waktu fungsi step fungsi alih 4

-->r5=csim('step',t,h5);   // respon waktu fungsi step fungsi alih 5

-->r6=csim('step',t,h6);   // respon waktu fungsi step fungsi alih 6

-->plot(t,r1)              // plotting respon waktu fungsi alih 1

-->plot(t,r2)              // plotting respon waktu fungsi alih 2

-->plot(t,r3)              // plotting respon waktu fungsi alih 3

-->plot(t,r4)              // plotting respon waktu fungsi alih 4

-->plot(t,r5)              // plotting respon waktu fungsi alih 5

-->plot(t,r6)              // plotting respon waktu fungsi alih 6

Hasil Grafik respon waktu

Posted in Program open source, scilab, Teori | Tagged , | 2 Comments

Sistem orde dua: fungsi alih

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 dihidari 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.

Fungsi alih sebuah sistem kontrol merupakan perwujudan karakter keluaran terhadap masukan. Pemodelan sistem Massa-Pegas-Damper seperti yang diposting disini, merupakan inspirasi dari fungsi alih orde dua secara ideal. Kebanyakan sistem loop-tertutup dan sensor didisain sebagai sistem orde dua untuk analisis yang teliti.

Fungsi alih (Transfer Function) orde dua secara ideal dapat dituliskan sebagai berikut:

Dimana: adalah besarnya penguatan dari sistem, adalah frekwensi alamiah dari sistem dan adalah rasio redaman (damping rasio) dari sistem.

Catatan

Sensor secara tipikal didisain secara linier yang diketahui penguatannya (biasanya K =  1), rasio redaman (damping ratio) sebesar:

dan bandwidth () besarnya paling sedikit 10x dari bandwidth sistem loop-tertutup.

 Pada frekwensi rendah relatif terhadap wn akan menjadi:

Pada frekwensi tinggi relatif terhadap wn akan menjadi:

Dobel integrator   akan mengarah ke 40db/dekade (dalam hal magnitude) pada frekwensi tinggi.

Rasio Redaman (Damping Ratio)

Gambar 1: Magnitude Bode dari fungsi alih orde dua secara ideal

 

Gambar 2: Fasa Bode dari fungsi alih orde dua secara idea

Rasio redaman (damping ratio) berasal dari sistem massa-pegas-peredam seperti yang diposting disini.  Dalam fungsi alih orde 2 secara ideal rasio redaman dapat memberikan efek yang sangat berpengaruh pada respon sistem.

 Catatan:

Frekwensi alamiah yang ditunjukkan dalam gambar adalah  dalam Hz, begitu juga dalam persamaan 1adalah dalam rad/s Konversi antara dua parameter adalah: .

Gambar 1 menunjukkan bahwa peak magnitude dari fungsi alih tergantung kepada  dan . Mengatur penguatan sistem secara keseluruhan adalah sangat sederhana, juga parameter K tidak begitu dipentingkan. Namun, tidak ada cara untuk mengkompensasi atau menyesuaikan   dalam sistem nyata. Gambar 2 menunjukkan ketergantungan pergeseran fasa pada dengan . Jelas bawah dengan paling kecil, pergerakan fasa 0 sampai -180 derajat sangatlah cepat sekali.

Catatan:

Ketika pemodelan  sistem mencocokkan dengan data fasa yang terukur, jalan yang terbaik adalah mencocokkan dibandingkan dengan magnitude. Pengukuran akan terjadi pada titik dikrit dan akan melewatkan puncak magnitude yang sebenarnya. Pecocokan kemiringan pergeseran fasa akan memberikan yang terbaik dengan mencocokkan dengan .

Puncak Magnitude (Peak Magnitude)

Puncak Magnitude merupakan fungsi . Hubungan ini adalah sebagai berikut:

Gambar 3: Bode Plot memberikan detail besarnya puncak magnitude

 

 

Frekwensi puncak (Peak Frequency)

Frekwensi dari puncak magnitude tidak sama dengan . Walaupun dan sangat dekat hubungannya. Hubungan antara dan sebagai berikut:

 

 

 

 

 

 

 

Posted in scilab, Teori | Tagged , | Leave a comment