Control Digital de Velocidad de Un Motor DC

Control de Velocidad Digital PID de un Motor DC de Escobillas Autor: Ing. Carlos Narváez Universidad de Oriente email: [email protected]

Introducción En el presente trabajo se desarrolla un Control de velocidad en lazo cerrado de un motor DC de Escobillas aplicando el conocido algoritmo de control PID. El objetivo es mantener mantener constante la velocidad ante variaciones de la carga (perturbaciones), de manera automática. El sistema se realizó usando un motor DC de escobillas extraído de una impresora de inyección de tinta, el cual es controlado por un H-bridge basado en un chip LMD18200 que permite usando la técnica PWM variar la velocidad del motor y su sentido de giro. Como unidad de realimentación, se utiliza un tacómetro construido como se detalla más adelante y todo el sistema es controlado por un microcontrolador PIC18F452.

Sistema de Control de Lazo Cerrado Tal como se muestra en la fig. 1, el sistema consta de un pequeño motor DC de escobillas, cuya sección de potencia la constituye un H-Bridge que permite, por un lado, definir la dirección de giro y por otro, controlar la velocidad con la aplicación de una señal PWM. El lazo de control es cerrado usando un tacómetro construido con un disco de acetato codificado colocado en el eje del motor y el el cual se hace pasar pasar por un foto interruptor, interruptor, para producir producir así así pulsos cuya cantidad por unidad de tiempo es proporcional a la velocidad de giro del motor.

Fig. 1 Control de Lazo Cerrado

Modulación de Ancho de Pulso (PWM) Es el mecanismo utilizado utilizado para variar la velocidad velocidad de un motor DC de escobillas. escobillas. Consiste en variar la anchura de pulso o el duty cycle en un ciclo de PWM de manera de variar el average de la tensión DC aplicada al motor, tal como muestra la fig. 2.

Carlos A. Narváez V, 2008

Fig. 2 Modulación de Ancho de Pulso PWM es una manera eficiente, para simular un rango de valores análogos usando circuitos digitales. Switchando rápidamente entre cero voltios y el voltaje nominal del motor, se obtiene un valor promedio comprendido entre esos dos límites. Tres señales son presentadas en la figura arriba, todas tienen la misma frecuencia, pero el ancho de los pulsos son diferentes. Variando la duración del tiempo “on”, el motor puede ver un promedio de cualquier valor entre 0V y +V. Frecuencias recomendadas para PWM están entre 20 y 30 Khz.

H-Bridge El H-Bridge es básicamente un mecanismo para hacer girar un motor DC en dirección hacia adelante y en reversa. Un H-Bridge típico de motores DC de escobillas es el integrado LMD18200 de Nacional Semiconductors el cual puede suministrar continuamente hasta 3 Amp VS

. 1uf

10nf

U1 6 3 5 4 7 8

1

Vs

B1

Dir

Out1

PWM

Out2

Brake

B2

Ground S ens e

TF O

LMD18200

1

+

2 10

A

11 9

-

10nf

2

MOTOR DC

Fig. 3 H-Brigde LMD18200


y opera con suministro de voltaje de hasta 55 Voltios. Tiene protección contra sobrecarga, sus entradas son compatibles TTL y CMOS. Usa PWM para regular la velocidad del motor y tienes pines para las funciones de: freno, dirección, sensor de corriente y señal de advertencia de temperatura. El pin sense sirve de sensor de corriente de salida. Tiene una sensibilidad de 377 microamperio por amperio de corriente de salida. Usando una resistencia de 2.7K se tiene 0.999 Voltios por amperio de salida. El pin TOF es una señal de advertencia de temperatura. Es una salida colector abierto que se vuelve ¨0¨ a 145 grados centígrados. El pin Brake realiza un freno de emergencia del motor cuando este pin pasa a ¨1¨y el pin PWM también. El LMD18200 puede manejar señales PWM del tipo Signo-Magnitud y Locked-antiphase las cuales se describen a continuación.

PWM Locked-antiphase La Señal PWM de tipo Locked-antiphase, consiste en un única señal de anchura de pulso variable en la cual se codifica tanto la información de dirección como la de amplitud. El 50% de la anchura de pulso representa cero. Valores por debajo del 50% representan dirección reversa y valores por encima del 50% representan dirección hacia adelante del motor. Para el LMD18200 el uso de este tipo de señal PWM implica usar el pin 3 (DIR) como entrada de la señal PWM, mientras el pin 5 (PWM) se lleva a valor lógico 1. Una de las grandes ventajas de usar señales PWM del tipo locked-antiphase es que sólo se necesita una línea I/O para controlar completamente el motor. Si se tiene restricciones de líneas I/O, esta puede ser una buena opción.

PWM Signo Magnitud Si se usa señal PWM del tipo signo-magnitud, el microcontrolador establece la dirección de giro del motor a través de un pin del H-Brigde destinado para tal fin (Dir) y varia la cantidad de potencia aplicada al motor o duty-cicle con otro pin del H-Brigde denominado PWM. La ausencia de pulso o lógica 0 en forma continua representa cero y lógica 1 en forma continua representa 100%. Este tipo de señal, por su sencillez, se ha usado en la realización del presente trabajo.

Implementando Modulación de Ancho de Pulso (PWM) en un PIC Para obtener una señal PWM, se usa el timer2, el cual establece la frecuencia de la señal PWM cargando un valor en el registro PR2. El ciclo se inicia con un reset, donde timer2 pasa a cero, luego se va incrementando hasta que su valor iguale a PR2, momento en que ocurre un nuevo reset y así sucesivamente. La anchura del pulso ó el tiempo que la señal permanece a 1 (duty cycle), viene dado por el valor cargado en el registro CCPR1L:CCP1CON<5:4> (8bits ó 10bits). Así cuando ocurre un reset del timer2, el pin de salida PWM pasa a 1, luego cuando timer2 iguale el valor cargado en el registro CCPR1L:CCP1CON<5:4>, el pin de salida PWM pasa a 0. El timer2 continua su conteo hasta que iguale a PR2 y un nuevo reset ocurre.


Fig. 4 Ciclo PWM

La fig. 4 muestra un ciclo de una señal PWM. La instrucción setup_ccp1(CCP_PWM) configura el módulo CCP1 como PWM, entonces la patita RC2/CCP1, funciona como salida PWM. El periodo de duración de un ciclo de PWM esta determinado por el valor cargado en PR2 según la fórmula: PWM_Periodo=(1/clock)*4*t2div*(PR2+1) PR2=((PWM_periodo*clock)/(4*t2div))-1

y la anchura de pulso (duty cycle) o tiempo que la señal PWM esta alta durante cada ciclo, viene dada por la formula: Duty_cycle= value*t2div*(1/clock)

si value es LONG INT y Duty_cycle= value*t2div*4*(1/clock)

si value es INT. Donde value es el valor cargado en CCPR1L:CCP1CON<5:4> (8bits ó 10bits).

El Duty Cycle puede se establecido usando la instrucción: set_pwm1_duty(value);

La instrucción: Setup_timer_2(mode, P, postscale)

permite establecer el periodo del PWM dado un valor de PR2 entre 0 y 255. Este valor determina cuando timer2 se resetea iniciando así un ciclo de PWM. Postscale es un número entre 1 y 16 que determina cuantas veces el timer2 se resetea antes de ocurrir una interrupción.


Ejemplo: Si clock = 20MHZ y PR2 = 127, entonces, un ciclo de PWM dura: Periodo = 1/20000000)*4*1*128 =

25.6 us

Luego usando la instrucción: setup_timer_2(T2_DIV_BY_1, 127, 5);

Tenemos que Timer2 se incrementa cada 200nseg, reset cada 25.6 useg y genera una interrupción cada 25.6 * 5 = 128 useg. Además si hacemos PR2 igual a 100, un valor de 45 en CCPR1L crea un duty cycle de 45%, un valor de 65 en CCPR1L crea un duty cycle de 65%.

Tacómetro digital El tacómetro se construyó usando un foto-interruptor CNZ1021 a través del cual se hace pasar un disco de acetato codificado colocado en la parte posterior del eje del motor. La fig. 5 muestra un disco codificado de 12 pulsos/rev. Los pulsos emitidos se hacen pasar por el Smithtrigger 7414 y realimentados al microcontrolador para así calcular la velocidad de rotación del motor.

Fig. 5 Disco Codificado 12 Pulsos/revolución

La fig. 6, muestra el circuito del tacómetro construido utilizando un foto-interruptor CNZ1021 y un acondicionador de señal Smith Trigger 7414.

+5VDC

180

10 K

74 14

1

2

Señal

CNZ1021

Fig. 6 Tacómetro Carlos A. Narváez V, 2008

Implementando un Control PID La acción de control PID en controladores analógicos esta dada por: t  1 de(t )  u (t ) = K e(t ) + ∫ e(t )dt + Td  Ti 0 dt  

(1-1)

Donde e(t) es la entrada al controlador (señal de error), u(t) es la salida del controlador, K es la ganancia proporcional, Ti es el tiempo integral (o tiempo de reajuste) y Td es el tiempo derivativo (o tiempo de adelanto). Para obtener la función de pulso del controlador PID digital, se puede discretizar la ecuación 1.1 aproximando el término integral mediante la sumatoria trapezoidal y el término derivativo mediante diferencias de dos puntos, así se obtiene: −  T T (1 − Z 1 )  + + Td U ( Z ) = K 1 −  E ( Z ) −1 2 Ti T − Ti ( 1 Z )  

(1.2)

ó

U ( Z ) E ( Z )

= Kp +

Ki −1

1 − Z

+ Kd (1 − Z −1 )

(1.3)

donde:

Kp = K −

Ki =

KT 2Ti

= K −

Ki 2

KT

Kd =

Ti KTd T

Ganancia Proporcional

Ganancia Integral

Ganancia Derivativa

y T es el periodo de muestreo.


Nótese que la ganancia proporcional para el controlador PID digital es más pequeña que la ganancia K para el controlador PID analógico por un factor de Ki/2. La ecuación 1.3 puede ser realizada utilizando programación paralela como indica la figura 7.

p(kT) Ki

+ + T +

e(kT)

u(kT)

Kp + +

Kd

-

q(kT)

T

Fig. 7 Realización paralela de un controlador PID

Se puede implementar en un computador digital usando el siguiente seudo-código:

BEGIN DO FOREVER Obtenga el set point: Obtenga la salida del sistema: Calcule el error: Calcule el término I: Calcule el término D: Calcule la Salida PID: Envíe control al motor

r(kT) y(kT) e(kT)=r(kT)–y(kT) P(kT)=Ki.e(kT)+p(kT-T) q(kT)=Kd.e(kT)–Kd.e(kT-T) u(kT)=p(kT)+Kp.e(kt)+q(kT)

Guarde variables:

p(kT-T)=p(kT) e(kT-T)=e(kT)

Espere hasta próximo periodo de muestreo ENDDO END


Sintonización de los parámetros del PID Conociendo el modelo matemático del motor, es decir su función de transferencia de lazo abierto, podemos aplicar numerosos métodos que incluye la representación de Bode, método de Laplace, respuesta en frecuencia, criterio de Nyquist, lugar geométrico de la raíces y otros para hallar los parámetros del PID adecuados. Como criterio de diseño general, se escogen los parámetros de tal manera que el sistema en lazo cerrado sea estable, de respuesta rápida y sin sobrepaso. Como herramienta de trabajo se pueden usar programas como MATLAB. Existen también, métodos experimentales tales como el ideado en 1942 por John G. Ziegler y Nathaniel B. Nichols que partiendo de la respuesta del proceso a un escalón unitario en lazo abierto, se pueden obtener los parámetros del PID. Ziegler y Nichols también describieron una técnica de ajuste en lazo cerrado. En casos donde no tenemos el modelo del motor, ni podamos aplicar métodos experimentales como Ziegler y Nichols, se puede utilizar un método de prueba y error basado en el conocimiento de lo que cada acción de control (proporcional, integral y derivativa) aporta a la acción de control general del sistema. Por simplicidad utilizaremos esta técnica en el presente trabajo, la cual se describe a continuación: 1) Se requiere de una manera de variar instantáneamente el valor de referencia (set-point) de cero al máximo de la velocidad esperada. Esto es equivalente aplicar un escalón a la entrada del controlador. 2) Teniendo la ganancia integral y derivativa a cero. Aplique un escalón repetidamente variando cada vez la ganancia proporcional hasta obtener un valor razonable de Kp. Esto es que la respuesta se aproxime a la entrada y oscile continuamente alrededor de la entrada con una pequeña cantidad de amortiguamiento. Si la oscilación no decrece gradualmente en su amplitud, entonces el sistema es considerado inestable. 3) Luego que se encuentre un valor razonable para Kp, se trabaja con el ajuste de Kd. Aplique un escalón repetidamente variando cada vez la ganancia derivativa hasta obtener un valor razonable de Kd. Esto es que la respuesta se amortigue rápidamente eliminando las oscilaciones alrededor de la entrada y permaneciendo en un valor ligeramente menor que el valor de la entrada. Esto es lo que se denomina error de estado estable y que puede ser corregido con el ajuste de Ki. 4) Luego que se encuentre un valor razonable para Kd, se trabaja con el ajuste de Ki. Aplique un escalón repetidamente variando cada vez la ganancia integral hasta obtener un valor razonable de Ki. Esto es eliminar el error de estado estable tal que la respuesta sigue a la entrada. Este parámetro debe ajustarse cuidadosamente pues puede introducir inestabilidad en el sistema.

Periodo de Muestreo Como periodo de muestreo se toma normalmente 1/10 del tiempo de subida del sistema en lazo cerrado. El tiempo de subida se define como el tiempo necesario para que el sistema pase del 10% al 90% del valor final de la respuesta. Otro criterio que se puede usar es 1/10 de la constante de tiempo del sistema. La constante de tiempo de un sistema se define como el tiempo necesario para que la respuesta a un escalón unitario alcance el 63% del valor final de la respuesta. Para un sistema que logra su valor final a los 2 seg. se toma como periodo de muestreo T igual a 0.12 seg. que es 1/10 de la constante de tiempo del sistema.


Hardware La fig. 8 muestra el prototipo desarrollado que consta de: Motor DC de escobillas 25 Voltios, tacómetro, H-Bridge basado en el LMD18200 y fuente de poder 5VDC para la lógica TTL. La alimentación de 25VDC para el motor se obtuvo de una fuente de poder variable de laboratorio. El microcontrolador y el resto del circuito se implementó en un break-board separado.

Motor DC

Fuente Poder +5VDC

Tacómetro

Control LMD18200

Fig. 8 Prototipo Control Motores DC de escobillas

La fig. 9 muestra el diagrama esquemático utilizado en este trabajo. En el podemos observar lo siguiente: Se utiliza cuatro potenciómetros conectados a cuatro canales del convertidor analógico digital del PIC18F452, los tres primeros representan los parámetros del controlador digital (Kp, Ki y Kd) y el último establece la velocidad referencia o setpoint. Se utiliza una pantalla LCD de 16X2 caracteres, comandada por dos interruptores (push-botton) los cuales permiten desplegar información variada, uno de ellos despliega la información en sentido hacia delante y el otro en reversa. El LMD18200 ha sido configurado para ser utilizado en modo PWM signo-magnitud. La dirección de giro se escogió de manera arbitraria, en este caso colocando el pin Dir a “1” y el freno (pin Brake) se deshabilitó colocando este pin a “0”. La señal PWM se obtiene configurando el módulo CCP1 del microcontrolador en modo PWM y los pulsos generados por el tacómetro son realimentados al microcontrolador y contados configurando el TIMER1 en modo contador. El microcontrolador trabaja a 10Mhz.


+5VDC

+5VDC

+5VDC +5VDC

Kd

Ki

100

Kp

100

RPM

100 100

10K 0.1uf

10K

10K

0.1uf

0.1uf

10K 0.1uf

+5VDC

10nf

10K

2 3 4 5 6 7

VDD .1uf

33 34 35 36 37 38 39 40

.1uf

13 14

1K

LED 1 10Mhz

11 32

RA0 RC0/T1OSO/T1CKI RA1 RC1/T1OSI RA2 CCP1/RC2 RA3 RC3/SCK/SCL RA4/TOCKI RC4/SKI/SDA RA5/SS RC5/SDO RC6/TX/CK INT0/RB0 RC7/RX/DT INT1/RB1 INT2/RB2 RD0/PSP0 CCP2/RB3 RD1/PSP1 RB4 RD2/PSP2 RB5 RD3/PSP3 RB6 RD4/PSP4 RB7 RD5/PSP5 RD6/PSP6 OSC1/CLKIN RD7/PSP7 OSC2/CLKOUT RE0/RD MCLR/VPP RE1/WR RE2/CS S S VDD S S VDD V V

PIC18F452

2 1 1 3

15 16 17 18 23 24 25 26

+5VDC 25VDC 6 3 5 4 7 8

1 Vs B1 2 Dir Out1 10 PWM Out2 11 Brake B2 Ground 9 Sense TFO

+

A

10K 1

7414 2

Señal

10nf

+5VDC

8 9 10

180

2

LMD18200

19 20 21 22 27 28 29 30

+5VDC

1

U4

CNZ1021 MOTOR DC

10K

+5VDC

4 3 2 1 0 1 1 1 1 1 9 8 7 6 5 4 3 2 1 7 6 5 4 3 2 1 0 E S E S C D D D D D D D D W / R E S C V R V V

LCD-Display

22pf

+5VDC 4.7K

Fig. 9 Diagrama Esquemático del Sistema


Software El Software fue escrito utilizando el compilador C de CCS inc. Los valores de los parámetros del PID se obtienen a través de canales del convertidor analógico digital de 10bits. Estos valores son puestos a formato q7, para que estén en un rango de 0 a 1. El rango de los parámetros del PID se modifican, cambiando el valor de esta variable. Toda la aritmética se realiza utilizando formato q7 a fin de evitar overflow. El lazo PID se realiza cada 26 miliseg y la actualización del duty cicle del módulo PWM se realiza cada 408 microseg. El despliegue de información en la pantalla LCD se refresca cada segundo.

/////////////////////////////////////////////////////////////////////////// //// MAESTRO_PID.C //// //// Control PID de Velocidad de un Motor DC //// //// Versión Aritmetica Fixed Point //// /////////////////////////////////////////////////////////////////////////// #include <18f452.h> #device ADC=10 #fuses HS,PUT,BROWNOUT,WDT128,NOLVP #use fast_io(A) #use fast_io(B) #use fast_io(C) #use fast_io(D) #use fast_io(E) #use delay(clock=10000000,RESTART_WDT) #use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7) #zero_ram #define TIMER3_DIV 120 #byte #byte #byte #byte

PORTA PORTB PORTC PORTE

= = = =

0xF80 0xF81 0xF82 0xF84

#bit SYSLED = PORTB.4 #define LEDTIME 10 #byte TMR1L #byte TMR1H

= 0xFCE = 0xFCF

/* definitions for Timer1 module */

#define ALL_OUT 0 #define ALL_IN 0xff /************************************************************************** * Variables Globales **************************************************************************/ int tickcount, t; unsigned ledticks; unsigned int16 wheel_counts, wheel_test, last_counts; unsigned int16 delta_counts; signed int16 pwmSet; unsigned int16 Driver_pwm; signed int16 error; unsigned int16 iPrev; signed int8 error_S8, ePrev;


//definiciones para motor trabajando a 25 Voltios DC #define MIN_PULSES 1 /* Mínimo pulsos por periodo de muestreo */ #define MAX_PULSES 21 /* Máximo pulsos por periodo de muestreo */ #define MAX_PWM 1015 /* Maximo PWM (100%) del controlador */ #define MIN_PWM 40 /* Minimo PWM del controlador */ unsigned int channel; unsigned int16 P_Term, I_Term, D_Term; signed int8 P_Term_q7, I_Term_q7, D_Term_q7; unsigned int16 Vel, P_GAIN, I_GAIN, D_GAIN; signed int8 P_GAIN_S8, I_GAIN_S8, D_GAIN_S8; #include "lcd-pd.h" /************************************************************************** * Leer Velocidad Motor **************************************************************************/ void read_Vel(void) { SET_ADC_CHANNEL(0); delay_us(10); Vel = READ_ADC(); // Motor Velocidad, escala0-1023 } /************************************************************************** * Leer Ganancias PID **************************************************************************/ void read_pid_Gain(void) { SET_ADC_CHANNEL(1); delay_us(10); P_GAIN = READ_ADC(); // Ganancia Proporcional P_GAIN_S8 = P_GAIN>>3; // Formato q7 SET_ADC_CHANNEL(2); delay_us(10); I_GAIN = READ_ADC(); // Ganancia Integral I_GAIN_S8 = I_GAIN>>3; SET_ADC_CHANNEL(3); delay_us(10); D_GAIN = READ_ADC(); // Ganancia derivativa D_GAIN_S8 = D_GAIN>>3; } /************************************************************************** * desplegar datos segun channel **************************************************************************/ void desplegar_datos(int channel) { switch(channel) { case 0: printf(displays,"\r P printf(displays,"\n%D %D break; case 1: printf(displays,"\rVel. printf(displays,"\n%04LU break; case 2: printf(displays,"\rError printf(displays,"\n%5ld break; case 3: printf(displays,"\rPwmSet printf(displays,"\n%5ld break; }

I D "); %D ",P_GAIN_S8, I_GAIN_S8, D_GAIN_S8);

Counts %04LU

"); ",Vel, Delta_counts);

"); ",error);

"); ",pwmSet);

}


/************************************************************************** * Enviar datos puerto Serial **************************************************************************/ void rs232(void) { // printf("%05LU,", conta0); // printf("%03LU,", timer0); // printf("%01.4f,", vout0); // printf("%01.4f,", vout1); // printf("%01.4f,", vout2); // printf("%01.4f,", vout3); // printf("\n\r"); } /************************************************************************** * Actualiza el contador tick, retorna no-cero si cambia **************************************************************************/ short geticks(void) { static BYTE tc, lastc=0; tc = ((get_timer3()>>8) - lastc); if (tc >= TIMER3_DIV) { tickcount++; lastc += TIMER3_DIV; return 1; } return 0; } /*************************************************************************** * Chequea si timeout usando el contador tick dado ***************************************************************************/ short timeout(int &var, int tout) { short ret=0; if (!tout || tickcount-var>=tout) { var = tickcount; ret = 1; } return(ret); }

/************************************************************************** * Interrupcion INT0 **************************************************************************/ #INT_EXT // Switch Display UP void EXT0_isr(void) { if(channel == 3) channel = 0; else channel++; }


/************************************************************************** * Interrupcion INT1 **************************************************************************/ #INT_EXT1 // Switch Display Down void EXT1_isr(void) { if(channel == 0) channel = 3; else channel--; } /************************************************************************** * Actualiza PWM Duty Cycle **************************************************************************/ #int_TIMER2 void TIMER2_isr(void) // 408 microseg - 2450.98 Hz. { // update PWMs during rollover for // glitch-free operation set_pwm1_duty(Driver_pwm); // put x% duty on Drive Signal } /*************************************************************************** * Lazo PID ***************************************************************************/ #int_timer3 void timer3_isr(void) // Periodo de muestreo cada 26 miliseg { t = t + 1; Wheel_counts = TMR1H; wheel_counts = wheel_counts<<8; Wheel_counts += TMR1L; Wheel_test = TMR1H; wheel_test = wheel_test<<8; Wheel_test += TMR1L; if(Wheel_test != Wheel_counts) { Wheel_counts = TMR1H; wheel_counts = wheel_counts<<8; Wheel_counts += TMR1L; } //velocidad del motor en pulsos/periodo de muestreo delta_counts = (Wheel_counts - last_counts); last_counts = Wheel_counts; read_vel();

//Velocidad Referencia (Setpoint) Escala 0-1023

// Escale delta_counts a valores PWM (0-1023) para usar la misma // escala y calcule el Error error = (vel - ((delta_counts*MAX_PWM) / MAX_PULSES)); error_S8 = error>>3; // rango -128 a 127 //multipicación 8x8 con signo utilizando formato q7 I_Term = iprev + ((signed int16)I_GAIN_S8 * (signed int16)error_S8); D_term = ((signed int16)D_GAIN_S8 * ((signed int16)error_S8 - (signed int16)ePrev)); p_term = (signed int16)P_GAIN_S8 * (signed int16)error_s8; P_term_q7 = P_term >>7; I_term_q7 = I_term >>7; D_term_q7 = D_term >>7;

// repone formato q7

pwmSet = pwmSet + (P_Term_q7 + I_Term_q7 + D_term_q7) ;

//Acción de control


if(pwmSet > MAX_PWM) { //Evita Windup I_term = iprev; pwmSet = MAX_PWM; } else if(pwmSet < MIN_PWM) { I_term = iprev; pwmSet = MIN_PWM; } // Guarde el //usado como ePrev iPrev

error actual y el término integral actual para se valores previos en el próximo periodo de muestreo = error; = I_Term;

Driver_pwm = (int16) pwmSet; }

/************************************************************************** * Programa Principal **************************************************************************/ void main() { setup_adc_ports(ALL_ANALOG); // Configura los 8 Convertidores setup_adc(ADC_CLOCK_DIV_32); // A/D setup_wdt(WDT_ON); // Perro guardian ON setup_timer_1(T1_EXTERNAL|T1_DIV_BY_1); // Contador eventos Externos setup_ccp1(CCP_PWM); // Configura modulos CCP1 como PWM setup_timer_2(T2_DIV_BY_4, 255, 1); // PWM 2.44Khz, interrupción 40 mseg setup_timer_3(T3_INTERNAL|T3_DIV_BY_1); // Real time interval 26 milliseg set_tris_A(ALL_IN); set_tris_B(0x0F); set_tris_c(0x01); set_tris_D(ALL_OUT); LCD_SETUP(); disp_serial = FALSE; disp_lcd = TRUE; timeout(ledticks,0); port_b_pullups(false); read_pid_Gain(); // Leer ganancias PID set_pwm1_duty(0); enable_interrupts(INT_EXT); ext_int_edge(0,H_TO_L); enable_interrupts(INT_EXT1); ext_int_edge(1,H_TO_L); enable_interrupts(INT_TIMER2); enable_interrupts(INT_TIMER3); enable_interrupts(GLOBAL); while(1) { restart_wdt(); geticks(); if(timeout(ledticks, LEDTIME)){ } if(t > 38) {

// Una vez por segundo....

read_pid_Gain(); SYSLED = !SYSLED; rs232(); desplegar_datos(channel); t = 0; } } }


Conclusiones La realización de un control PID es una tarea sencilla, pero la entonación de los parámetros es compleja. Partiendo del conocimiento del efecto de cada parámetro sobre la acción de control total y experimentando con diferentes valores, se puede obtener un rendimiento satisfactorio del sistema.


Control Digital de Velocidad de Un Motor DC

Recommend Documents