Experimentos con Arduino: octubre 2014

Los controladores PID (Proporcional/Integral/Derivativo) (wikipedia) son muy utilizados para controlar procesos de todo tipo.

Existe mucha documentación en la web donde se explica la teoría asociada y desarrollos tanto analógicos como discretos.

Simplificando podemos decir que la idea es medir un valor y compararlo con el valor deseado. En base a la diferencia de ambos valores (error) se genera una señal de ajuste para lograr que el valor medido se aproxime al valor deseado. El valor de ajuste se calcula mediante tres componentes :

Proporcional : Basado en el error actual (presente)
Integral : Basado en el historial de errores (pasado)
Derivativo : Basado en la proyección del error (futuro)

Vajuste = Kp * Proporcional + Ki * Integral + Kd * Derivativo

Las constantes de cada factor de la fórmula se seleccionan para determinar la curva de respuesta mas adecuada al proceso a controlar.

Cuando queremos utilizar un micro como controlador PID se utiliza un algoritmo discreto (se mide a ciertos intervalos de tiempo el valor de salida, se calcula el ajuste y se aplica la corrección).

A continuación tenemos un programa en pascal que permite simular el algoritmo PID en un micro de 8bits:

//   PID controller simulation

//  Serial configuration
//  Baud  Bits Parity Stop FlowControl
//  xxxx  8    N      1    None 
//  Led conected to port P0.0
//  20MHz -> 7200*2 = 14400 bauds

Program PID;
{$O+} 

Const
  Osc = 20000000; 
  BaudRateTimerValue = Byte (- Osc div 12 div 32 div 7200);
  UMAX= 0.2;   //Superior range
  UMIN=-0.2;   //Inferior range 
 
Var 
    SerialPort: Text;
   
    DelayTimer: Word; Volatile;
    control,set_point,measured_value,actual_error,error_previous:real;
    Pc,Ic,Dc:real;
    Kp,Ki,Kd:real;
    r:real;
    
Procedure Delay (DelayTime: Word);
var i,j:word;
begin
  for i:= 0 to DelayTime do   begin
    for j:= 0 to 32000 do begin end;
  end;
end;    

Procedure WriteToSerialPort; Assembler;
Asm
  CLR   TI
  MOV   SBUF, A
  @WaitLoop:
  JNB   TI, @WaitLoop
end;
 
Function ReadFromSerialPort: Char;
Var ByteResult: Byte absolute Result;
begin
  While not RI do;
  RI := False;
  ByteResult := SBUF;
  { Echo character }
  Asm
    MOV    A, Result
    LCALL  WriteToSerialPort
  end;
end;
 
Procedure Init;
begin
  TL1  := BaudRateTimerValue;
  TH1  := BaudRateTimerValue;
  TMOD := 100001;     
  SCON := %01010000;     
  TI   := True;         
  TR1  := True;  
  PCON := PCON or $80; //SMOD=1  por lo que dobla el baud de la fórmula inicial
  Assign (CurrentIO, ReadFromSerialPort, WriteToSerialPort);         
end;
 
{$DefaultFile On }

begin
  Init;
  Randomize;
  
  Writeln ('Discrete PID simulation');
  Kp:=10;
  Ki:=1;
  Kd:=1;
  set_point:=10.5;      //Desired Value
  measured_value:=5.5;  //Initial value
  error_previous:=set_point - measured_value;  //Initial error
  Ic:=0;
  r:=0;
  Writeln ('Desired Value:',set_point:10:5);
  Repeat
    actual_error   := set_point - measured_value; 
   
    Pc := actual_error;   //Current error
    Ic := Ic + error_previous;  //Sum of previous errors
    Dc :=  error_previous - actual_error ;  //Difference with previous error
    control:= Kp*Pc + Ki*Ic + Kd*Dc; 
    if (control > UMAX) then control := UMAX;    
    if (control < UMIN) then control := UMIN;
    error_previous := actual_error;  //error_previous holds the previous error
    writeln ('Measured Value=',measured_value:10:5,' Control=',control:7:3, 
             '  Pc:',Pc:10:5,' Ic:',Ic:10:5,' Dc:',Dc:10:5,' R:',r:10:5);
    delay(2);
    r:=random(100)/500;   // random interference
    measured_value:= measured_value + control + r ;
  until False;
end.

En la imagen se muestra la salida de la simulación donde se puede observar como el valor medido se va incrementando:

En la siguiente imagen podemos ver que el valor medido ya se aproximó al valor deseado, desplazándose hacia arriba y hacia abajo dependiendo del valor de interferencia r .

Es interesante ver como los factores Proporcional/Integral/Derivativo varían a lo largo de la simulación.

Algunos enlaces interesantes:

Experimentos con Arduino

Páginas

domingo, 5 de octubre de 2014

Simulación de controlador PID en micro 8051