velocidad constante en motores DC ante cambios bruscos de carga con PIC...

[Picuino]

En los motores se suele implementar una forma especial de PID que se llama I-PD

Esto significa que el control directo es integral y el proporcional y derivativo se colocan en el lazo de realimentación.
Se hace así para evitar que el motor sufra cambios repentinos de tensión y de corriente.

En nuestro caso, para hacer el control derivativo hay un problema: el motor es muy rápido comparado con la velocidad de toma de datos.
El control derivativo consigue hacer que el sistema sea más estable. Si el motor comienza a aumentar muy rápido la velocidad el control derivativo le va a frenar.
El problema es que nuestros motores pueden aumentar de 0% a 60% su velocidad entre dos intervalos de toma de datos back-emf.
En estas condiciones el control derivativo puede hacer poco para evitar que el motor se embale.

Para conseguir estabilidad, por ahora lo mejor será afinar bien el integral.


Más adelante se puede intentar un método más avanzado de control por simulación del motor:
Consiste en simular el funcionamiento del motor dentro del micro. Para eso debemos conocer los parámetros dinámicos del motor (inductancia, resistencia, inercia) y resolver las ecuaciones como lo haría un simulador de circuitos.
Al simular el motor se puede controlar la velocidad del motor simulado, en vez del motor real.
Esto permite aumentar la frecuencia de muestreo del bucle de control y controlar con un PID completo.
Cada cierto tiempo se deben medir los valores del motor real y ajustar los valores del motor simulado para que no se aparten mucho de la realidad.
Pero esto es otra historia mucho más compleja. Por ahora vamos a ver si funciona nuestro control Integral.

Saludos.

[Picuino]

Pero luego de algunas pruebas pude evidenciar que con el divisor de tension tenia una entrada de señal por el CAD de aprox. 1000 "puntos" lo que es equivalente a una entrada de tension de aprox 5 V cuando  insertaba un PWM señal con un ciclo de trabajo de 100% o 1000"puntos"

Eso es porque el ADC estaba saturado y por encima de 5 voltios de entrada siempre te dá una lectura de 1023.

Prueba lo siguiente:
Alimenta con 23.4 voltios la resistencia R7
Mide la tensión en el punto "analog" y dará 5 voltios (fondo de escala)




Saludos.

[Picuino]

Por lo tanto la señal BackEmf está multiplicada por 1023/23.4 = 43.7 puntos/voltio--> Entonces si no me equivoco la correccion seria de la siguiente manera:
Por lo tanto la señal BackEmf está multiplicada por 1023/5 = 204 puntos/voltio

Se debe comenzar en el mismo punto donde se termina (en este caso la unión de R7 con el motor)

   La señal medida por el micro comienza en R7
   La señal generada por el PWM temina en R7 (0 - 30 voltios)


Si divides 1023/5 estás comenzando a analizar en la señal "analog" que vale 5 voltios y estás olvidando la ganancia del divisor de tensión. (que baja de 30v a 5v)

De manera que si el divisor de tensión funciona OK y te da 5 voltios en analog cuando el motor tiene 30 voltios, la corrección debería ser:

   Por lo tanto la señal BackEmf está multiplicada por 1023/30 = 34.1 puntos/voltio

Pero insisto en que las pruebas que has hecho saturan al DAC.



De todas formas todo esto sólo vale si también tenemos los valores del motor.

¿Podrías medir los parámetros del motor?
  1. Resistencia equivalente
  2. Inductancia
  3. Inercia mecánica

Manual y hojas excel para medir los parámetros:
   https://sites.google.com/site/picuino/motor_equivalent_model#TOC-MODELADO-DE-UN-MOTOR-DE-CORRIENTE-C

  

Saludos.

[amyver]

Ok.... PICUINO comprendido.....

saludos...

[amyver]

Muy buenas a todos.... bueno comentar que el dia de ayer estube realizando algunas pruebas con el control Integral propuesto por el amigo PICUINO y la pruebas fueron muy alentadoras...

efectivamente el control funcionaba bastante bien a bajas velocidades, el problema estaba ahora a velocidades elevadas....pero bueno se me ocurio darle otra ganancia integral a partir de cierta velocidad....y bueno los resultados fueron otra vez bastante buenos....

A continuacion adjunto el circuito del Proteus 7.7sp2 asi como el codigo fuente compilado en PCWHD 4.084

Código: [Seleccionar]

/****************************************************************************
By: Amyver - Foro TODOPIC
*****VERSION 2B*****
Funciones:
*Modulo controlado atravez del interface USART
*Modulo usado CCP1
*El programa controla velocidad de un motor DC
 en dos sentido de giro, con la particularidad
 de mantener la velocidad constante ante cambios bruscos de carga
 
*Se soluciono el problema del reseteo del Micro usando
 amplificadores operacionales configurados como seguidores de voltaje
 dichos amplificadores fueron conectados a las salidas de los pines
 de -CCP1- -Control de Giro- y -Enable-
 ****************************************************************************/
#include <16F877A.h>
#device adc=10             //Definimos un Conversor Analogo/Digital con resolucion de 10 bits
#Fuses XT, NOWDT, NOPROTECT, NOLVP, PUT, BROWNOUT, NOCPD, NOWRT//palabra de configuracion
#Use delay(clock=4000000)  //usando un oscilador de 4MHz
#Use RS232(Baud=9600, Xmit=Pin_C6, Rcv= Pin_C7, Parity=N, Bits=8)

#Use Fast_io(B)
#Use Fast_io(C)

#Byte PortB=0x06
#Byte PortC=0x07

char var;
signed int16 senialError=0;
signed int16 lecturaBackEmf=0,fijarVelocidad=0,valorPWM=0;

void incrementarVelocidad()
{
 OutPut_High(Pin_C5);       //Habilitamos el driver L6203

 fijarVelocidad+=20;       //incrementamos la velocidad en 300
 
 if(fijarVelocidad>=1000)  //pregutamos si se llego a la velocidad tope hacia adelante
 {
  fijarVelocidad=1000;     //se fija una velocidad tope
 }
 if(fijarVelocidad>=0)     //Preguntamos si la velocidad es positiva (motor con giro hacia adelante)
 {
  OutPut_Low(Pin_C4);      //Habilitamos driver L6203 para el giro a la derecha 
  printf("\r\n\r\nVelocidad Programada=%Ld\r\n   ",fijarVelocidad);   
 }
 else
 {
  OutPut_High(Pin_C4);     //Habilitamos driver L6203 para el giro a la izquierda
  printf("\r\n\r\nVelocidad Programada=%Ld\r\n   ",fijarVelocidad);     
 }
}
void decrementarVelocidad()
{
 OutPut_High(Pin_C5);       //Habilitamos el driver L6203
 
 fijarVelocidad-=20;       //decrementamos la velocidad en 300
 
 if(fijarVelocidad<-1000)  //pregutamos si se llego a la velocidad tope hacia atras
 {
  fijarVelocidad=-1000;    //se fija una velocidad tope
 }
 if(fijarVelocidad>=0)     //Preguntamos si la velocidad es positiva (motor con giro hacia adelante)
 {
  OutPut_Low(Pin_C4);      //Habilitamos driver L6203 para el giro a la derecha 
  printf("\r\n\r\nVelocidad Programada=%Ld\r\n   ",fijarVelocidad);
 }
 else
 {
  OutPut_High(Pin_C4);     //Habilitamos driver L6203 para el giro a la izquierda
  printf("\r\n\r\nVelocidad Programada=%Ld\r\n   ",fijarVelocidad);     
 }
}
void pararMotor()          //paramos el motor
{
 fijarVelocidad=0;         //Establecemos la velocidad en cero
 OutPut_Low(Pin_C5);       //Deshabilitamos el driver L6203
 
 set_pwm1_duty((int16)0);  //se inicializa el PWM en Cero   
 printf("\r\n\r\nPARAR MOTOR=%Ld\r\n   ",fijarVelocidad);
}

void verificarRS232()      //Funcion encargada de verificar si existen datos en buffer
{                          //del USART
  if(kbhit())              //Preguntamos si existen datos pendientes a ser procesados
  {                        //Si, hay algo pendiente de recibir ...         
   var=getc();             //tomamos el dato ingresado por el usuario y lo almacenamos en
                           //una variable
   if(var==0x0D)           //preguntamos si se presiono Enter
   {
    incrementarVelocidad();//llamamos a la funcion incrementar velocidad
   }
   if(var==0x08)           //preguntamos si se presiono retroceso
   {
    decrementarVelocidad();//llamamos a la funcion decrementar velocidad
   }
   if(var==0x20)           //preguntamos si se presiono la barra espaciadora
   {
    pararMotor();          //funcion que para los motores
   }
  }
}
void testearBackEmf()
{
 delay_ms(7);         //tiempo que se enviara la señal PWM
 
 OutPut_Low(Pin_C5);   //Enable Motor OFF
 delay_ms(1);          //tiempo de espera para que la señal Back-emf se estabilice
 
 Set_adc_channel(1);   //selecion de canal 1
 delay_us(50);         //Retardo para que se carge la senal analogica
 lecturaBackEmf=read_adc();  //lee el resultado de la convercion y se guarda en nuestra variable de 16bits
 
 printf("\r\nLectura BACK-EMF=%Ld",lecturaBackEmf);
 OutPut_High(Pin_C5);  //Enable Motor ON
}
void ajustarVelocidad()
{
 signed int16 Control_I, KI;                 //Definimos variables enteras con signo
 signed int16 auxiliar=0,fijarVelocidadAux=0;//de 16 bits..

 if(fijarVelocidad>=0)                       //Preguntamos si se tiene una velocidad
 {                                           //positiva (Giro del motor en derecha)
  senialError= fijarVelocidad-lecturaBackEmf;//Tomamos la señal de error
  fijarVelocidadAux=fijarVelocidad;          //Guardamos el valor de la velocidad programada
 }                                           //puesto que sera usada despues
 else                                        //si la velocidad es Negativa(Giro del motor en Izquierda)
 {
  auxiliar=(int16)ABS(fijarVelocidad);       //Tomamos el valor ABSOLUTO de la variable "fijarVelocidad"
  senialError= auxiliar-lecturaBackEmf;      //la combertimos en una variable de 16 bits y la almacenamos.
  fijarVelocidadAux=auxiliar;                //Guardamos el valor de la velocidad programada
 }
 
 printf("\r\nSenial de Error=%Ld",senialError);

//////////////CONTROL INTEGRAL (propuesto por PICUINO)//////////////////////////
 if((fijarVelocidadAux>=0)&&(fijarVelocidadAux<=200)) //nos aseguramos de que la velocidad se
 {                                                    //encuentre entre estos dos rangos.
  KI =10;          // Ganancia integral
 }
 else                                                 //Si la velocidad programada es mayor a (PWM1->200)
 {                                                    //le daremos otra ganancia para que responda lento
  KI = 2;         // Ganancia integral                //con lo cual se lograra que el motor Oscile menos
 }                                                    //a altas velocidades.

 Control_I = (senialError * KI) / 8;                  //ecuaciones para el CONTROL INTEGRAL
 valorPWM += Control_I;                               //se almacena el la variable "valorPWM" el resultado del
                                                      //resultado arrojado por el control Integral
 if(valorPWM>=1000)                 //fijamos limites para la velocidad
  valorPWM=1000;     
 if((valorPWM<20))           
  valorPWM=0;
 
 set_pwm1_duty((int16)valorPWM);    //se da el nuevo valor al PWM
 printf("\r\n\r\nValor del PWM=%Ld\r\n   ",valorPWM);
}

void main()
{
 Set_Tris_B(0b11111110);            //Configuramos el pin RB0 como salida, los restantes como entradas
 Set_Tris_C(0b10001011);            //Configuramos los pines RC0,RC1,RC3 y RC7 como entradas, los restantes como salidas

 PortB=0x00;                        //limpiamos el puertoB
 PortC=0x00;                        //limpiamos el puertoC

 OutPut_High(Pin_B0);               //senializacion de pic ON

 setup_timer_2(T2_DIV_BY_1,249,1);  //configuramos el timer2, Prescaler=1,Periodo=249,Postcaler=1
                                    //con lo que se conseguira: T=250us o f=4Khz
                                    //"setup_timer_2(Prescaler,Periodo,Postcaler)"
 setup_CCP1(CCP_PWM);               //Escogemos el modo de trabajo de CCP1, lo escojemos como modulacion por ancho de pulso
                                    //NOTA.- Tanto para PWM1 y PWM2 el periodo es establecido por el timer2
                                    //NOTA2.-la resolucion maxima esta dada por: Tpwm=2exp(n) * 1/Fosc
                                    //                                           250us=2exp(n) * 1/(4exp(6))
                                    //                                           2exp(n)= 1000
                                    //Entonces el maximo valor que podemos cargar al "value" es de 1000 con lo que se
                                    //conseguira un ciclo de trabajo de 100% "set_pwm1_duty(value)"
////////////////////////////////////Configuracion de CAD////////////////////////////////////////////////////
 setup_adc(ADC_CLOCK_INTERNAL);     //Se usara un reloj interno
 Setup_adc_Ports(AN0_AN1_AN3);      //se configuran lo pines: RA0,RA1,RA2 como entradas analogicas
////////////////////////////////////////////////////////////////////////////////////////////////////////////
 set_pwm1_duty((int16)0);           //se inicializa el PWM en cero

 OutPut_High(Pin_C5);               //Enable Motor ON
 
 printf("\r\nSystem OK.\r\n");      //Sistema en linea y listo para transmitir

 while(true)
 {
  verificarRS232();
  testearBackEmf();
  ajustarVelocidad();
 }
}

Entonces estoy a la espera de criticas constructivas para mejorar el funcionamiento actual...

saludos...

[Picuino]

Hola amyver.
¿Puedes decirme que resistencia de inducido tiene tu motor?

La puedes medir con un polímetro (igual que si midieses una resistencia)

Otra forma de medir la resistencia es:
   Alimentar al motor con una tensión baja, por ejemplo con 1 voltio
   frenar el eje con la mano para que no se mueva
   Medir la intensidad que atraviesa el motor.
   Medir la tensión en bornes del motor

   Rm = V / I


Saludos.

[amyver]

Ah... olvidaba comentar que se opto por una solucion basada en AmpOp (Lm324) para solucionar el problema del reseteo del pic que aun persistia en cuanto el motor era sometido a cargas pesadas, los AmpOp fueron configurados como seguidores de voltaje y alimentados con 24Vdc y fueron puestos entre micro y L6203...

[amyver]

Lo medi con un multimetro de alta presicion y me arrojo un valor de 17 Ohm...

[amyver]

Una consulta PICUINO, te sirve la medida que realice??? o prefieres que la realice con el metodo de la tension y corriente???

[Picuino]

En principio valdrá con esa medida.

Se me olvidó comentarte que en algunos motores la medida varía dependiendo de la posición del eje, de forma que hay que medir la resistencia en varias posiciones del eje motor para asegurarse de que no varía.

El valor es muy alto. ¿Cuanto valen la corriente, la tensión y la potencia nominal?

Saludos.

[Picuino]

He leído en otro mensaje que tu motor tiene:

  U = 30v
  I  = 4 Amperios
  w = 30000 rpm

A lo que añadimos:

  Rm = 17 Ohmios

¿Es así?

Saludos.

[amyver]

Si, es correcto....

saludos...

[Picuino]

Los datos no concuerdan.

Piensa que si alimento al motor con 30 voltios, como máximo van a pasar unos dos amperios.

   I = V / R = 30 / 17 = 1.76 Amperios.

Creo que la resistencia es muy grande.

¿Puedes hacer la prueba de resistencia alimentando con 1 voltio?
Si la resistencia está bien medida, deberían pasar 59 mA.


Saludos.

[Picuino]

Estoy probando una placa que he diseñado para hacer pruebas sobre PCB.
Por ahora no funciona. No se que le pasa.
Cuando alimento a 12 voltios parece que todo está bien.

Luego conecto el microcontrolador y aparece un cortocircuito que se mantiene aunque desconecte el microcontrolador.
Si apago la alimentación y vuelvo a conectar la placa con el L6203, otra vez está en corto (0.3voltios a 0.3Amperios)

Al día siguiente, parece que la placa vuelve en sí.
Conecto la alimentación y puedo subir a 12voltios con un consumo de 0.01Amperios.
Vuelvo a conectar el PIC y la placa vuelve al cortocircuito.


Es el fallo más raro que me he encontrado nunca.

Saludos.

[Nocturno]

¿Puedes poner el diseño a ver si vemos algo?

¿Se calienta el L6203 al hacer corto?