Kendali PID

Rangkaian analog PID.

Kp adalah konstanta proporsional. Kp berlaku sebagai Gain (penguat) saja tanpa memberikan efek dinamik kepada kinerja kontroler. Ki adalah konstanta integral. Kontrol I dapat memperbaiki respon steady-state, namun pemilihan. Ki yang tidak tepat dapat menyebabkan respon transien (transient response) yang tinggi sehingga dapat menyebabkan ketidakstabilan system. Pemilihan Ki yang sangat tinggi justru dapat menyebabkan output berosilasi. Kd adalah konstanta derivatife dapat mengurangi efek overshoot (respon berlebihan) dalam menuju steady-state. Dengan kata lain, seolah-olah, control D mampu memprediksi error yang akan terjadi sebagai efek dari error yang dihitung sebelumnya.

Suatu sistem kontrol klasik kombinasi, baik PI ataupun PID, hanya dapat bekerja dengan baik untuk sistem H(s) yang cenderung linier dalam fungsi waktu. Artinya, persamaan dinamik dari model H(s) relatif tidak berubah selama rentang waktu pengontrolan. Padahal kenyataannya, tidak ada fenomena sistem riil yang benar-benar linier. Bahkan hampir semua fenomena kontrol mulai dari skala kecil misalnya kontrol motor DC, hingga skala sistem besar, misalnya kontrol pesawat terbang tanpa awak, jika dilakukan pemodelan secara rinci dan lengkap adalah sangat tidak linier (nonlinear). Setiap sistem riil selalu berhadapan dengan gangguan (disturbance). Motor selalu bermasalah dengan friksi pada poros, gearbox, perubahan karakteristik karena temperatur, dll. Pesawat di udara selalu berhadapan dengan tekanan udara yang berubah-ubah, angin, hujan, dsb.

Figure 2-1 adalah schematic dari sebuah sistem dengan menggunakan kendali PID. Kendali PID membandingkan nilai yang terukur di y dengan nilai referensi yaitu nilai setpoint, y0. Nilai selisih atau error,e, kemudian akan digunakan untuk menghitung input proses yang baru, u. Input ini akan mencoba mengatur proses yang terukur agar kembali pada setpoint yang diinginkan.

Alternatif lain selain PID loop tertutup adalah PID loop terbuka. Kendali loop terbuka (tidak mempunyai umpan balik) dalam banyak kasus tidak memuaskan. Dengan menambahkan umpan balik dari output, performansi system dapat ditingkatkan.

Tidak seperti algoritma kendali sederhana, kendali PID dapat memanipulasi input dari proses berdasarkan keadaan sebelumnya dan tingkat perubahan sinyal. Hal ini member keakuratan dan metode kendali yang stabil.

Ide dasarnya adalah bahwa system kendali membaca keadaan system menggunakan sensor. Kemudian nilai pembacaan tersebut akan dipakai untuk mengurangi nilai referensi yang diinginkan untuk menghasilkan nilai error. Kemudian nilai error akan diolah menjadi tiga, untuk menangani keadaan sekarang, melalui persamaan proporsional, mencatat keadaan sebelumnya, untuk persamaan integral, dan untuk memprediksi keadaan setelah sekarang, melalui persamaan derivative.

Ideal Versus Standard PID

PID sering ditemukan dalam industry, dan yang paling mudah adalah bentuk standard. Dalam bentuk ini Kp digunakan pada persamaan I dan D.

Figure 2-2 menunjukan schematic kendali PID, dimana Tp, Ti, dan Td menunjukan konstanta waktu dari proporsional, integral, dan derivative.

Td adalah waktu yang dibutuhkan untuk memprediksi keadaan selanjutnya. Komponen integral akan menyesuaikan dengan menjumlahkan semua nilai error sebelumnya dalam waktu Ti detik (atau sample).

Dalam bentuk idealnya adalah:

Dengan ini, jadi, Ki = Kp/Ti dan Kd=KpTd. Bentuk standar, meskipun sedikit lebih kompleks matematis, lebih digunakan pada industri.

Proporsional

Persamaan proporsional (P) memberikan input proporsional untuk system kendali dengan error. Pada banyak kasus, dengan hanya menggunakan kendali P dapat memberikan nilai error yang tidak berubah (stationary error) kecuali ketika nilai input dari system kendali bernilai nol dan nilai proses sistem sama dengan nilai yang yang diinginkan. Pada Figure 2-3 stationary error dalam system muncul setelah adanya perubahan pada nilai yang diinginkan atau referensi (desired value). Nilai P yang besar akan mengakibatkan system tidak stabil.

Integral

Kendali integral (I) adalah penjumlahan dari error sebelumnya. Proses penjumlahan error akan berlangsung sampai nilai dari output system sama dengan nilai referensi yang diinginkan, dan hasil ini dalam keadaan stationary error ketika nilai referensi stabil. Penggunaan control I biasanya digabung dengan P yang disebut control PI. Jika hanya menggunakan control I saja akan memberikan respon yang lambat dan seringkali mengakibatkan system berosilasi.

Derivatif

Control derivative adalah nilai dari tingkat perubahan error.  Control ini akan meningkatkan respon system. Control D biasanya akan digunakan dengan control P atau PI sebagai kontrol PD atau PID. Pemberian D biasanya menyebabkan system tidak stabil. Respon dari control PD memberikan respon rising yang cepat daripada kontroler P. Pada dasarnya control D mempunyai sifat sebagai highpass filter pada sinyal error.

Dengan menggunakan ketiga control semuanya, sebagai kontroler PID biasanya memberikan performansi yang baik. Figure 2-6 memberikan perbandingan P, PI, dan PID. PI meningkatkan performansi P dengan menghilangkan stationary error, dan PID meningkatkan performansi PI dengan respon yang lebih cepat dan tidak ada overshoot.

Tuning

Manual Tuning

Set Kid an Kd menjadi nol. Kemudian tingkatkan nilai Kp perlahan sampai mencapai osilasi lalu set kembali sekitar menjadi setengahnya. Tikngkatkan Ki sampai mencapai hasil yang lebih baik. Akan tetapi, nilai Ki yang terlalu besar akan menyebabkan system tidak stabil. Terakhir, tingkatkan nilai Kd. Akan tetapi terlalu besar nilai Kd akan menyebabkan respon yang berlebihan dan overshoot.

 

Parameter-parameter Tuning

Cara yang paling baik untuk mencari nilai parameter-parameter PID yang cocok adalah melalui pemodelan matematika dari system yang akan dikontrol, parameter-parameter tersebut dapat dihitung untuk mendapatkan respon yang diinginkan. Tapi sering kali deskripsi yang detail secara matematis dari sebuah system kadang tidak tersedia, untuk itu tuning dilakukan dengan cara eksperimen (dicoba-coba sampai mendapat nilai yang cocok) terkadang dilakukan. Menemukan nilai PID itu sendiri merupakan sebuah pekerjaan yang menantang. Pengetahuan yang baik terhadap komponen-komponen yang bekerja pada system dan mengetahui cara-cara kendali lain adalah sebuah dasar yang baik. Beberapa proses terkadang mengharuskan tidak adanya overshoot dalam proses kendali terhadap setpoint. Secara umum, yang paling penting adalah kestabilan. Sebuah proses diharuskan tidak berosilasi untuk semua kondisi. Selanjutnya, harus dapat tercapai dalam jangka waktu tertentu.

Ada beberapa metode untuk men-tuning PID. Pemilihan metode akan bergantung pada apakah proses bisa dituning secara online atau tidak. Metoda Ziegler-Nichols diketahui bersama sebagai sebuah cara untuk men-tuning secara online. Langkah pertama untuk men-tuning adalah mengatur konstanta gain I dan D menjadi nol, tingkatkan terus nilai penguatan P sampai terjadi osilasi yang stabil dan tanpa henti-hentinya (sebisa mungkin mendekati nilai yang diinginkan) pada output. Kemudian critical gain Kc(nilai Kp ketika system berosilasi terus-menerus secara teratur) dan perioda osilasi tersebut Pc sudah terekam dan nilai P, I dan D kemudian dapat ditentukan berdasarkan Table 2-1.

Selanjutnya, tuning parameter biasanya diperlukan untuk mengoptimasikan kinerja dari kontroler PID.

Harus digaris bawahi bahwa kontroler PID tidak akan bekerja dengan baik atau hanya akan bekerja pada area kecil sekitar system state tertentu. Terkadang bisa juga pada system non-linier, tetapi masalah umumnya datang pada kendali PID ketika system tidak stabil dan keadaan input tergantung pada keadaan system.

Kendali PID Diskrit

Sebuah kendali PID diskrit akan membaca error, menghitung dan memberikan putput terhadap input system pada waktu interval tertentu, pada perioda sampling T. Time sampling harus lebih kecil daripada konstanta waktu terkecil dari system.

Background Algoritma

Tidak seperti algoritma control sederhana, kendali PID dapat memanipulasi input system berdasarkan keadaan sebelumnya dan tingkat perubahan sinyal. Hal ini akan memberikan metode control yang lebih akurat dan stabil.

Figure 2-2 menunjukan schematic dari kontroler PID, dimana Tp, Ti, dan Td menyatakan konstanta waktu untuk proporsional, integral, dan derivative.

Fungsi alih berdasarkan system dari Figure 2-2:

Hubungan u dengan e dalam domain waktu adalah:

Pendekatan integral dan derivatife untuk mendapat bentuk diskret, menggunakan:

Dimana n adalah waktu diskret pada waktu t.

Sehingga persamaan dari kontroler:

Dimana:

Jika input control tidak berubah terhadap waktu, maka:

Implementasi

Contoh fungsi PID

  /*This file has been prepared for Doxygen automatic documentation generation.*/   
  /*! \file *********************************************************************  
   *  
   * \brief General PID implementation for AVR.  
   *  
   * Discrete PID controller implementation. Set up by giving P/I/D terms  
   * to Init_PID(), and uses a struct PID_DATA to store internal values.  
   *  
   * - File:               pid.c  
   * - Compiler:           IAR EWAAVR 4.11A  
   * - Supported devices:  All AVR devices can be used.  
   * - AppNote:            AVR221 - Discrete PID controller  
   *  
   * \author               Atmel Corporation: http://www.atmel.com \n  
   *                       Support email: avr@atmel.com  
   *  
   * $Name: RELEASE_1_0 $  
   * $Revision: 1.1 $  
   * $RCSfile: pid.c,v $  
   * $Date: 2006/02/16 11:46:13 $  
   *****************************************************************************/   

  #include "pid.h"   
  #include "stdint.h"   

  /*! \brief Initialisation of PID controller parameters.  
   *  
   *  Initialise the variables used by the PID algorithm.  
   *  
   *  \param p_factor  Proportional term.  
   *  \param i_factor  Integral term.  
   *  \param d_factor  Derivate term.  
   *  \param pid  Struct with PID status.  
   */   
  void pid_Init(int16_t p_factor, int16_t i_factor, int16_t d_factor, struct PID_DATA *pid)   
  // Set up PID controller parameters   
  {   
    // Start values for PID controller   
    pid->sumError = 0;   
    pid->lastProcessValue = 0;   
    // Tuning constants for PID loop   
    pid->P_Factor = p_factor;   
    pid->I_Factor = i_factor;   
    pid->D_Factor = d_factor;   
    // Limits to avoid overflow   
    pid->maxError = MAX_INT / (pid->P_Factor + 1);   
    pid->maxSumError = MAX_I_TERM / (pid->I_Factor + 1);   
  }   

  /*! \brief PID control algorithm.  
   *  
   *  Calculates output from setpoint, process value and PID status.  
   *  
   *  \param setPoint  Desired value.  
   *  \param processValue  Measured value.  
   *  \param pid_st  PID status struct.  
   */   
  int16_t pid_Controller(int16_t setPoint, int16_t processValue, struct PID_DATA *pid_st)   
  {   
    int16_t error, p_term, d_term;   
    int32_t i_term, ret, temp;   

    error = setPoint - processValue;   

    // Calculate Pterm and limit error overflow   
    if (error > pid_st->maxError){   
      p_term = MAX_INT;   
    }   
    else if (error  -pid_st->maxError){   
      p_term = -MAX_INT;   
    }   
    else{   
      p_term = pid_st->P_Factor * error;   
    }   

    // Calculate Iterm and limit integral runaway   
    temp = pid_st->sumError + error;   
    if(temp > pid_st->maxSumError){   
      i_term = MAX_I_TERM;   
      pid_st->sumError = pid_st->maxSumError;   
    }   
    else if(temp  -pid_st->maxSumError){   
      i_term = -MAX_I_TERM;   
      pid_st->sumError = -pid_st->maxSumError;   
    }   
    else{   
      pid_st->sumError = temp;   
      i_term = pid_st->I_Factor * pid_st->sumError;   
    }   

    // Calculate Dterm   
    d_term = pid_st->D_Factor * (pid_st->lastProcessValue - processValue);   

    pid_st->lastProcessValue = processValue;   

    ret = (p_term + i_term + d_term) / SCALING_FACTOR;   
    if(ret > MAX_INT){   
      ret = MAX_INT;   
    }   
    else if(ret  -MAX_INT){   
      ret = -MAX_INT;   
    }   

    return((int16_t)ret);   
  }   

  /*! \brief Resets the integrator.  
   *  
   *  Calling this function will reset the integrator in the PID regulator.  
   */   
  void pid_Reset_Integrator(pidData_t *pid_st)   
  {   
    pid_st->sumError = 0;   
  }

File lainnya

/*This file has been prepared for Doxygen automatic documentation generation.*/   
  /*! \file *********************************************************************  
   *  
   * \brief Example of use of general PID implementation for AVR.  
   *  
   * Example of how to setup and use the general PID implementation in pid.c.  
   *  
   * - File:               main.c  
   * - Compiler:           IAR EWAAVR 4.11A  
   * - Supported devices:  All AVR devices can be used.  
   * - AppNote:            AVR221 - Discrete PID controller  
   *  
   * \author               Atmel Corporation: http://www.atmel.com \n  
   *                       Support email: avr@atmel.com  
   *  
   * $Name: RELEASE_1_0 $  
   * $Revision: 1.1 $  
   * $RCSfile: main.c,v $  
   * $Date: 2006/02/16 11:46:13 $  
   *****************************************************************************/   

  #include    
  #include    
  #include "stdint.h"   
  #include "pid.h"   

  /*! \brief P, I and D parameter values  
   *  
   * The K_P, K_I and K_D values (P, I and D gains)  
   * need to be modified to adapt to the application at hand  
   */   
  //! \xrefitem todo "Todo" "Todo list"   
  #define K_P     1.00   
  //! \xrefitem todo "Todo" "Todo list"   
  #define K_I     0.00   
  //! \xrefitem todo "Todo" "Todo list"   
  #define K_D     0.00   

  /*! \brief Flags for status information  
   */   
  struct GLOBAL_FLAGS {   
    //! True when PID control loop should run one time   
    uint8_t pidTimer:1;   
    uint8_t dummy:7;   
  } gFlags = {0, 0};   

  //! Parameters for regulator   
  struct PID_DATA pidData;   

  /*! \brief Sampling Time Interval  
   *  
   * Specify the desired PID sample time interval  
   * With a 8-bit counter (255 cylces to overflow), the time interval value is calculated as follows:  
   * TIME_INTERVAL = ( desired interval [sec] ) * ( frequency [Hz] ) / 255  
   */   
  //! \xrefitem todo "Todo" "Todo list"   
  #define TIME_INTERVAL   157   

  /*! \brief Timer interrupt to control the sampling interval  
   */   
  #pragma vector = TIMER0_OVF_vect   
  __interrupt void TIMER0_OVF_ISR( void )   
  {   
    static uint16_t i = 0;   
    if(i  TIME_INTERVAL)   
      i++;   
    else{   
      gFlags.pidTimer = TRUE;   
      i = 0;   
    }   
  }   

  /*! \brief Init of PID controller demo  
   */   
  void Init(void)   
  {   
    pid_Init(K_P * SCALING_FACTOR, K_I * SCALING_FACTOR , K_D * SCALING_FACTOR , &pidData);   

    // Set up timer, enable timer/counte 0 overflow interrupt   
    TCCR0A = (1<<CS00);   
    TIMSK0 = (1<<TOIE0);   
    TCNT0 = 0;   
  }   

  /*! \brief Read reference value.  
   *  
   * This function must return the reference value.  
   * May be constant or varying  
   */   
  int16_t Get_Reference(void)   
  {   
    return 8;   
  }   

  /*! \brief Read system process value  
   *  
   * This function must return the measured data  
   */   
  int16_t Get_Measurement(void)   
  {   
    return 4;   
  }   

  /*! \brief Set control input to system  
   *  
   * Set the output from the controller as input  
   * to system.  
   */   
  void Set_Input(int16_t inputValue)   
  {   
    ;   
  }   

  /*! \brief Demo of PID controller  
   */   
  void main(void)   
  {   
    int16_t referenceValue, measurementValue, inputValue;   
    Init();   
    __enable_interrupt();   

    while(1){   

      // Run PID calculations once every PID timer timeout   
      if(gFlags.pidTimer)   
      {   
        referenceValue = Get_Reference();   
        measurementValue = Get_Measurement();   

        inputValue = pid_Controller(referenceValue, measurementValue, &pidData);   

        Set_Input(inputValue);   

        gFlags.pidTimer = FALSE;   
      }   
    }   
  }   

  /*! \mainpage  
   * \section Intro Introduction  
   * This documents data structures, functions, variables, defines, enums, and  
   * typedefs in the software for application note AVR221.  
   *  
   * \section CI Compilation Info  
   * This software was written for the IAR Embedded Workbench 4.11A.  
   *  
   * To make project:  
   *  
   * Add the file main.c and pid.c to project.  
   * Under processor configuration, select desired Atmel AVR device.  
   * Enable bit definitions in I/O include files  
   *  High optimization on speed is recommended for best performance  
   * 
   *  
   * \section DI Device Info  
   * The included source code is written for all Atmel AVR devices.  
   *  
   * \section TDL ToDo List  
   * \todo Put in own code in:  
   * \ref Get_Reference(void), \ref Get_Measurement(void) and \ref Set_Input(int16_t inputValue)  
   *  
   * \todo Modify the \ref K_P (P), \ref K_I (I) and \ref K_D (D) gain to adapt to your application  
   * \todo Specify the sampling interval time \ref TIME_INTERVAL  
   */

Permasalahan pada Integral

Biasanya nilai integral akan menjadi cukup tinggi ketika terjadi perbedaan yang mencolok antara PV(process value) dan SP(setpoint value) dikarenakan pada system terdapat beban(load) yang besar melebihi kemampuan system. Jika dalam kontroler menggunakan integral, hal ini bisa jadi masalah. Nilai dari konstanta integral akan terus bertambah, dan ketika beban yang besar dihilangkan, maka PID akan menghasilkan nilai selisih yang besar sampai konstanta integral kembali normal.

Hal ini dapat dicegah menggunakan beberapa cara. Dengan membatasi nilai konstanta integral agar tidak melewati nilai dari MAX_I_TERM. Nilai dari MAX_I_TERM tergantung pada system dan waktu sampling yang digunakan.

 

Daftar Pustaka

Pitowarno, Endra.2006.”ROBOTIKA: Desain, Kontrol, dan Kecerdasan Buatan”. Percetakan Andi Offset. Yogyakarta. Indonesia.

AVR221: Discrete PID controller. ATMEL.

http://www.eetimes.com/ContentEETimes/Documents/Embedded.com/2000/f-wescot.pdf

http://en.wikipedia.org/wiki/PID_controller

http://faculty.petra.ac.id/handy/download/Slide%20Kontroler%20PID%203.ppt

About these ads

7 Responses to Kendali PID

  1. mantap masbro, izin share ya..

  2. tatang_soetarma says:

    Izin bookmark mas.. materinya keren (–,)d …mau nanya nih mas, ada contoh kontrol kecepatan motor dengan fuzzy logic gak mas? *pakai Codevision
    makasih banyak atas ilmunya :)

  3. Al Rosyada says:

    mau donk mas control fuzzy pake codevision…:d

  4. posting tentang kontrol PIDnya bagus.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.