Control PID con PIC

[kruskal]

Hace unos dias me tope con este sencillo pero excelente documento http://www.arian.cl/downloads/nt-010.pdf muy explicativo. Me abrio del deseo de aprender mas.

Me gustaria si alguien que pueda enviar informacion o que haya realizado alguna implementacion de control PID con PIC. Tambien seria interesante tener datos de otros tipos de control automatico como el Fuzzy

Salud2

[gu1llermo]

Excelente información haz publicado, gracias por ello.

Adicionalmente recomendaría estos dos:

PID controller using Back EMF as the Control Feedback

Motores DC controlados a cristal/PIC/ o lo que sea...

Esta última es un poco fastidiosa porque a cada rato se recarga 

Con estos 3 yo creo que es suficiente como para implementar éste control PID, por mi parte ya realicé un seudocódigo, todavía no lo e implementado, al hacerlo lo publico en éste mismo hilo.

PD: del segundo enlace que publiqué, la parte que considero más relevante es ésta:

3) Con ambas posiciones (Posición Actual y posicion Deseada), ejecutas el siguiente algoritmo PI (sistema de control realimentado P+I o proporcional + integrador, que calcula la tensión que se le debe dar al motor para que la posición actual se haga igual a la deseada

Inicio:
ErrAcum = 0

Bucle:
- Leer PosA de contador del encoder (o del encoder absoluto)
- Leer PosD del contador que procesa las señales de paso y dirección del programa CNC
- Calcular el error total y el error acumulado de posicion
Error = PosD - PosA
ErrAcum = ErrAcum + Error
- Limitar los valores
Si ErrAcum > 255 entonces ErrAcum = 255
Si ErrAcum < -255 entonces ErrAcum = -255
- Calcular la tensión de salida que maneja el motor
Vmotor = CP * Error + CI*ErrAcum
- Limitar los valores de tensión de salida
Si Vmotor > 100 entonces Vmotor = 100
Si Vmotor < -100 entonces Vmotor = -100
Repetir en forma periódica desde "Bucle", periódica significa a 100 veces por
segundo (para un motor DC debiera ser suficiente. La velocidad de repetición del bucle de este algoritmo DEBE ser constante, ya que sino, el motor puede volverse
inestable, ya que variaría la velocidad a que se acumula el error integral.

- El signo de Vmotor da el sentido en el que se debiera mover el motor (en realidad, sentido en el que el puente H manda que se mueva el motor),
y el valor absoluto de Vmotor da el porcentaje de la tension de alim del motor (directamente el ancho de los pulsos periódicos que manejan el puente H en microsegundos). Si Vmotor es 0, el puente H permanecerá apagado

CP es la constante proporcional del algoritmo de realimentacion del motor, y CI la constante integral. Ambos valores deben calibrarse para que el motor converja lo más rápido a la posición deseada y no oscile. El término integral CI sirve para suprimir el juego y la fricción de los mecanismos, ya que si el motor está cerca de la posición deseada, se le da muy poca tensión de alimentación, por lo que el mismo a veces no es capaz de moverse. Al ir acumulando el error a lo largo del tiempo, lentamente se le va incrementado la tensión hasta que el motor finalmente se mueve.

Hay muchísima info sobre la calibración de estos términos "CP" y "CI", pero son casi todas teóricas, y muy poco info práctica. Digamos que a ojímetro y de oido es posible calibrarlos de la siguiente forma para cada motor:
-Empieza con CI = 0, CP=1.
-Haz un programa CNC para que el motor específico se mueva lo más rápido posible a una posición dada desde otra en el mismo eje, y pare.
-Si el motor llega a la posición y se pasa, luego vuelve, se pasa para el otro lado, etc, quiere decir que CP es demasiado grande, y debes achicarlo.
-Si el motor va muy lento a la posición especificada, aunmenta CP.
-Debes encontrar el punto en el que el motor va lo más rápidamente posible a la posición pero no se pasa (o se pasa infimamente). Cuando estés en ese punto es posible que, aunque el motor no se pase, emita un ruido raro. Significa que está oscilado pero sin moverse. En ese caso disminuye CP un poquito.
-Una vez fijado CP, deberás ajustar CI usando el mismo método.. Incrementa CI hasta que el motor oscile en su posicion y luego lo decrementas hasta que no lo haga.

PD2: y del primer enlace, la parte que considero más relevante es:

/* implements PID control */
void PIDfb(void)
{
  signed long pwmSet;
  static signed long ePrev;
  signed long error;
 
  if (runState != R_OFF)      // only calculate PWM values if moving or holding
  {
    error = genPos - currPos;         // error is desired-current position
    pwmSet = pGain * error  +         // standard PID equation
             iGain * eInteg + 
             dGain * (error - ePrev); // derivative is current-previous
    eInteg += error;                  // integral is simply a summation over time
    ePrev = error;                    // save previous for derivative
  }
  else
    pwmSet = 0;
 
  SetPWM(pwmSet);           // set PWM value to motor

//  printf("e%ld cp%ld 1V%ld 2V%ld\n\r", error, currPos, adcV1, adcV2);
}

que corresponde al código en C.

Saludos.

[gu1llermo]

A continuación expongo el cuasi seudocódigo que pienso implementar para lograr éste control:

Código: [Seleccionar]

Error=1;
Error_acumulado=0;
Error_anterior=0;
Bucle
   Kp=10000/(Pb*SP);
   Ki=Kp*I;
   Kd=Kp*D;
   Error=SP-PV;
   Error_acumulado= Error_acumulado + Error;
   Out=Kp*Error+Ki*Error_acumulado+Kd*(Error-Error_anterior);
   Si (Out>100)  Entonces Out=100;
   Si (Out<-100) Entonces Out=-100;
   Si (Out>0) Entonces sentido_giro_motor=derecha;
   else sentido_giro_motor=izquierda;
   PWM_duty=abs(Out)
   Error_anterior=Error;
Regresar a Bucle;
Bueno básicamente es eso, para los que quieren saber el significado de cada variable, en el artículo que publicó kruskal está bien explicado.

Restaría hacer las pruebas necesarias para determinar los valores de Pb, I, D.

Saludos.

[gu1llermo]

Una cita del amigo jesús, muy buena:

La implementación del PID es:

Término proporcional:

1) e_func = v_des - v_act; /* error function */
2) r_mot = Kp*e_func; /* motor output */

Término integrativo:

1 static int r_old=0, e_old=0;
2 ...
3 e_func = v_des - v_act;
4 r_mot = r_old + Kp*(e_func-e_old) + Ki*(e_func+e_old)/2;
5 r_mot = min(r_mot, +100); /* limit output */
6 r_mot = max(r_mot, -100); /* limit output */
7 r_old = r_mot;
8 e_old = e_func;

Término derivativo:

1 static int e_old=0;
2 ...
3 e_func = v_des - v_act; /* error function */
4 deriv = e_old - e_func; /* diff. of error fct. */
5 e_old = e_func; /* store error function */
6 r_mot = Kp*e_func + Kd*deriv; /* motor output */
7 r_mot = min(r_mot, +100); /* limit output */
8 r_mot = max(r_mot, -100); /* limit output */

Todo junto el PID al completo implementado en "C":

static int r_old=0, e_old=0, e_old2=0;
2 ...
3 e_func = v_des - v_act;
4 r_mot = r_old + Kp*(e_func-e_old) + Ki*(e_func+e_old)/2
5 + Kd*(e_func - 2* e_old + e_old2);
6 r_mot = min(r_mot, +100); /* limit output */
7 r_mot = max(r_mot, -100); /* limit output */
8 r_old = r_mot;
9 e_old2 = e_old;
10 e_old = e_func;

Ajuste de los parámetros o sintonización del PID:

1. Select a typical operating setting for the desired speed, turn off integral
and derivative parts, then increase KP to maximum or until oscillation
occurs.
2. If system oscillates, divide KP by 2.
3. Increase KD and observe behavior when increasing/decreasing the
desired speed by about 5%. Choose a value of KD which gives a damped
response.
4. Slowly increase KI until oscillation starts. Then divide KI by 2 or 3.
5. Check whether overall controller performance is satisfactorily under
typical system conditions.


Con esto más la información que has puesto, te tiene que permitir implementar el PID.

Un saludo

[MLO__]

Hola

Yo implemete un controlador PI de tempertura en un PIC18F452 a un sistema de refrigeracion. Lo fundamental en el control PID es el modelado matematico del sistema y del actuador, ya que de ahi se deducen las variables de sintonizacion y de tiempo de respuesta, obviamente el PID se aplica mas facilmente si el sistema es de primer orden.

El "truco" que yo utilice para ahorrar espacio en la memoria del PIC para embeber el PI (y no utilizar tablas y hacer el muy socorrido PID estatico) fue desarrollarlo con transformada Z con lo cual se llega a una ecuacion en diferencias, esta ecuacion es muy sencilla de resolver y ademas el PI se vuelve dinamico!!!!.

Obviamente el control aca utilizado tiene la ventaja de operar sobre un sistema lento, este factor (el tiempo) es muy importante a la hora de discretizar el controlador.

En el documento esta el ejemplo de la discretizacion del controlador implementado.

Con respecto al fuzzy, hay programas en los cuales uno define los conjuntos difusos y el genera el codigo para embeberlo(FuzzyTech, Matlab..), en el control fuzzy no es necesario el modelo matematico del sistema ya que el control se realiza solo con el conocimiento empirico del proceso (esto implica que hay que conocerlo muy muy muy bien). El control fuzzy es mas rapido y mas adaptable, por eso para sistemas de orden superior y de varias entradas varias salidas es mejor implementar Fuzzy que PID.

[manex_1987]

Yo estoy deseando de implementar un sistema de control por mi mismo. Y claro, en un chisme de microchip!

Nose... no tengo mucha esperiencia en PIDs, pero supongo que ajustando con cierta documentacion y en definitiva experiencia ajena, las 3 constantes del PID, no hara falta mucho conocer las ecuaciones dinamicas del sistema, no? Claro, no podras optar a estabilizar el sistema exactamente como tu quieras, pero empiricamente yo creo que se podrian lograr buenos resultados. Claro, en sistemas de ordenes bajos.

Lo de las ecuaciones en diferencias esta muy bien, pero el problemilla es que hay coma flotante en medio, cosa que chupa muchos recursos. Pero... para sacar la eq en diferencias hace falta la TZ? No basta con discretizar la derivada y la integral en base al periodo de muestreo usado?

un saludo

[MLO__]

Uno de los metodos para hallar las constantes del controlador es (como esta en el documento adjunto) con la curva de respuesta del sistema en lazo abierto a una funcion pulso, de ahi se toman los valores de t del sistema y se hallan las demas constantes, es el metodo no parametrico, pero ahi se esta suponiendo que el sistema es de primer orden (claro que en la curva de respuesta se debe acercar mucho a una exponencial para hacer esa afirmacion).

Con respecto a la discretizacion de la derivada.....eso es aplicar la transformada z, solo que en algunos documentos le llaman factor 'q' (de cuantizacion). La gran ventaja de hacerlo con transformada z es el hecho de poder elegir el orden del retenedor (normalmente de orden cero), ademas hay sistemas los cuales se estabilizan cuando se discretizan (presion sobre todo). En cuanto a los recursos..... pues, si es en punto flotante y eso consume recursos, pero el PID es un flitro de 2 orden como maximo y eso implica solo 4 constantes en la ecuacion en diferencias.

En esto del control lo importante es el margen de error que debe tener la senal de salida y el sobrepaso maximo limite para no danar el actuador. Algo que no se puede obviar es la funcion de transferencia del actuador, ya que es justamente este elemento el que actua sobre el sistema y va ha hacer que este trabajando dentro de un rango determinado del 'set point' elegido.

No esta de mas conocer la dinamica del sistema, ya que de esta manera queda mucho mas sencillo el decidir si se agregan ceros o polos para estabilizarlo y ademas se determina que tan influyente es la variable de control sobre el sistema a controlar. Ocurre a veces que por controlar una variable obviamos la de mayor peso y el sistema nunca va ha ser estable (me ocurrio!!!!!) y uno se puede 'matar' sacando curvas de respuesta y nada!!!! es desesperante....

un saludo

[gu1llermo]

Hola! Renatox_, eso si es muy importante para tener en cuenta, yo ya me lo estaba imaginando lo de la componente integral, si la distancia es muy grande esta se pasará del SP y luego tiene que regresarse muy pero muy lento, hasta que el error acumulado sea 0.

Será por eso que en uno de los enlaces que publiqué anteriormente el autor limita el error acumulado, para que no llegue a ser tan alto? no entendía porque lo hacía.

...
Inicio:
ErrAcum = 0

Bucle:
- Leer PosA de contador del encoder (o del encoder absoluto)
- Leer PosD del contador que procesa las señales de paso y dirección del programa CNC
- Calcular el error total y el error acumulado de posicion
Error = PosD - PosA
ErrAcum = ErrAcum + Error
- Limitar los valores
Si ErrAcum > 255 entonces ErrAcum = 255
Si ErrAcum < -255 entonces ErrAcum = -255
- Calcular la tensión de salida que maneja el motor
Vmotor = CP * Error + CI*ErrAcum
- Limitar los valores de tensión de salida
Si Vmotor > 100 entonces Vmotor = 100
Si Vmotor < -100 entonces Vmotor = -100
Repetir en forma periódica desde "Bucle", periódica significa a 100 veces por
segundo (para un motor DC debiera ser suficiente. La velocidad de repetición del bucle de este algoritmo DEBE ser constante, ya que sino, el motor puede volverse
inestable, ya que variaría la velocidad a que se acumula el error integral.
...

Entonces siguiendo la recomendación del autor, con implementar un PI  sería suficiente, ahora bien que valor límite del error acumulado será conveniente? un 5% del recorrido total? ó también tengo que hacer pruebas modificando el valor del tope para el error acumulado y quedarme con el que haga que llegue a la posición deseada más rápido? de forma estable claro.

Saludos.

[gu1llermo]

La respuesta anterior corresponde a éste comentario del compañero Renatox.

Hola guillermo, ten cuidado implementar un PID de posición es diferente a uno de velocidad ya que tus puntos de inicio y fin pueden estar muy cerca como también muy lejos, si la calibración de tu PID te da 1seg, entonces en teoría demoraría 1seg en ir de 0mm a 1mm y de 0mm a 100mm, en el segundo caso puede que se sature mucho la componente integral por el area del error, y tu motorcito salte mucho incluso que no llegue a su posición final por error matemático en los cálculos, por eso es mejor que actives el PID a cierta distancia del punto final.

saludos.

[gu1llermo]

Otra información importante:

VARIANTE EN EL ALGORITMO PID

[manutek]

Gracias por el dato guillo , espero algún día poder ayudarte en algo

[gu1llermo]

Bueno no sé si mostrar éste vídeo aquí o en otro lado, pero aquí fué donde nació la acción de control que finalmente utilicé para controlar las articulaciones de los robots Cilíndrico y SCARA con los que trabajé y les dí vida para que realizacen tareas repetitivas.

Este es un vídeo del funcionamiento del robot SCARA haciendo una tarea de marcar 5 puntos dibujados en un papel, la precisión obtenida fué sorprendente.

Aqui una foto del mismo:



estoy subiendo a youtube el del cilindrico, al terminar lo adjunto también, mientras dos imagenes:



Si se fijan en las gradillas podrán observar que el error tenía que ser cero para poder agarrar los tubos de ensayo y volverlos a colocar en su sitio, teniendo presente que el motor de la base tiene un juego esa precisión entra en un milagro  el truco está en mover poco a poco la articulación para que no oscile, además que le agregué una acción integral, bueno todo esto lo explicaré en detalle más adelante, al jurado les gustó mucho la acción de control que utilicé y me dijeron para hacer un paper, la semana que viene lo empiezo a redactar, y también quiero sacar una explicación menos formal y bastante práctica para acá, para el foro, al tenerlo lo publico, mientras a descansar un poco 

Vídeo:

Saludos.

[manex_1987]

Usaste un P-PI para controlar la trayectoria? (dos lazos en cascada)

[gu1llermo]

Hola! Manex, nop, use un perfil de velocidad de forma trapezoidal en conjunto con una acción integral, no tiene nada que ver con PID, ni combinacion P-PI en cascada, se podría decir que es tiene un perfil de forma trapezoidal en cascada con un I, luego más adelante explico en detalle, esta semana me siento hacerlo, mientras voy a recuperar el sueño 

Saludos.

[manex_1987]

Mmm dejame que intuya, eso de perfil de velocidad me suena a una accion proporcional no lineal... me equivoco? Seguro que si ajajajaj