Feb 152016
 
17. Control PID con microcontrolador PIC
5 (100%) 7 votes

El controlador PID es uno de los controles más utilizados actualmente en la industria debido a su fácil sintonía y robustez en los diferentes procesos existentes. Este es utilizado para llevar una variable física (Nivel, temperatura, velocidad, presión, etc) a un punto de operación específico (set point).  Al final del post hay un video explicativo de toda esta entrada.

Una vez termines de estudiar todo el contenido de este post puedes ver un segundo ejemplo de PID en pic en un proceso real para una planta MOTOR GENERADOR danco click aca

 

En esta entrada, vamos a aprender cómo podemos programar nuestro propio controlador PID en nuestro microcontrolador. Para eso debemos tener claro, como es una estructura clásica de control. Así, que en la siguiente figura se muestra un lazo de control en malla cerrada donde C es el controlador (en este caso el PID) y P es nuestro proceso.

Malla cerrada controlador

donde r(k) es nuestra señal de referencia o set point, e(k) es nuestra señal de error (La resta entre r(k) y y(k)), C(z) es nuestro controlador PID discreto, u(k) es nuestra señal de control (Ley de control), P(z) es nuestra planta o proceso en representación discreta, y(k) es nuestra variable de salida a controlar.

 

La ley de control PID puede representarse por la siguiente ecuación:

u(t)=k_pe(t)+\dfrac{k_p}{t_i}\int_{0}^{t}e(t)dt+k_pt_d\dfrac{de(t)}{dt}

y en dominio de s es representado por:

u(s)=k_p\left [ 1+\dfrac{1}{t_is}+t_ds \right ]e(s)

El control PID posee tres parámetros (k_p,t_i,t_d) ganancia proporcional, tiempo integral y tiempo derivativo respectivamente. Existen numerosas técnicas y autores que tratan como sintonizar o ajustar dichos parámetros. En esta entrada, les voy a enseñar TRES formas diferentes de sintonizar este controlador. Para eso y antes que nada, debemos conocer el modelo matemático o el comportamiento de nuestro proceso que queremos controlar (en el diagrama de arriba seria el bloque P(z)).

 

Típicamente, todo proceso industrial es representado por funciones de transferencia de primer o segundo orden. A continuación es expuesto un modelo de primero orden sobre el cual vamos a trabajar para poder modelar el comportamiento de nuestra planta.

P(s)=\dfrac{Ke^{-\theta s}}{\tau s +1}

El modelo está representado en su forma continua, es decir en el dominio de Laplace. donde K es la ganancia del sistema, \tau es la constante de tiempo del proceso y \theta es el retardo del proceso.

 

Para entender cómo obtener estos tres parámetros de nuestro proceso, vamos a hacerlo directamente en el ejemplo, para que aprendamos de manera práctica a modelar un proceso rápidamente y posteriormente poder sintonizar o ajustar nuestro controlador PID para que pueda controlar dicho proceso.

Ejemplo

En este ejemplo vamos a programar un controlador PID en nuestro PIC, para controlar la temperatura de un horno y poderla mantener en el punto de operación deseado, en este caso se le pide al ingeniero de control que el horno debe mantener su temperatura constante en torno de los 150.0°C. Se pide además al ingeniero, que adapte un LCD 4×20 para poder visualizar la temperatura actual del horno, y el setpoint.

Control PID con PIC

Antes que nada vamos a necesitar los siguientes componentes en el PROTEUS para poder simular nuestro proceso: PIC16F887, IRFZ44N, LM044L, CELL, RES, OVEN.

 

Comencemos primero con nuestro proceso (El horno de temperatura), vamos a buscar el horno en proteus (OVEN) y vamos a darle doble click para configurarle sus parámetros:

 

  • Control PID Horno con PICTemperatura ambiente: 25°C
  • Temperature coefficient (V/°C): da una idea de la temperatura que alcanzará el horno según la tensión aplicada. Valor: 1V/°C.
  • Oven Time Constant (sec): es la constante de tiempo del horno. Para evitar una simulación muy larga, vamos a colocarlo en 10 segundos.
  • Heater time constant (sec): es la constante de tiempo del calefactor. Para evitar simulaciones largas la ponemos en 1 segundo.
  • Thermal resistence to ambient (°C/W): resistencia térmica horno ambiente. Valor por defecto 0.7.
  • Heating Power (W): es la potencia del horno. A fin de que nuestro sensor de temperatura no sobrepase los 5 voltios de tensión, vamos a colocar este parámetro en 52 W.

Como sensor de temperatura se pueden usar termopares, termocuplas, RTD, etc. Ahora, como el dispositivo OVEN tiene un terminal que dice T, el cual nos indica la temperatura del horno en grados CELCIUS. Para esto es conveniente utilizar un divisor de voltaje por 100 para obtener la señal del horno en milivoltios. Asi, 25°C corresponderán a 250mV.

Listo, una vez configurado nuestro horno, vamos a proceder a identificar el modelo matemático que mas o menos represente la dinámica de nuestra variable de proceso (La temperatura). Note que en nuestro diagrama, estamos alimentando el horno con una batería de 12V, para poder determinar nuestro modelo matemático, vamos a tener que hacer una identificación off-line. Para eso necesitamos estimular nuestro horno y almacenar los datos que este nos da, para poder graficar su comportamiento. Asi, estimulamos nuestro horno con un valor del 10% al 20% de nuestro valor nominal que son 12V. Entonces vamos a energizar el horno con 2V y graficar la curva que genera.

Malla Abierta

(En el video de youtube, les explicaré como obtener esa gráfica desde el proteus)

Miremos entonces la respuesta que obtuvimos de nuestra gráfica:

Grafica escalón

Vemos que la gráfica comienza en 25°C y llega hasta 132°C y que para conseguir esta respuesta tuvimos que alimentar la resistencia con 2V. Así podemos obtener la ganancia del proceso con la siguiente formula:

K=\dfrac{Y_{final}-Y_{inicial}}{U_{final}-U_{inicial}}

K=\dfrac{132-25}{2-0}=53.5

Observemos que la temperatura en la gráfica, se comienza a estabilizar mas o menos a los 40 segundos (Linea Roja), así podemos obtener la constante de tiempo de la variable temperatura con la siguiente formula:

T_{establecimieto}=4\tau

Osea que el \tau=10, esto era de esperar, pues nosotros mismos ya habíamos colocado una contaste de tiempo de 10 en los parámetros del horno.

Si te está sirviendo de algo la información de la pagina, podrías invitarme a un café y ayudarme a seguir manteniendo en pie el sitio WEB. Solo cuesta $2USD y me ayudarías enormemente a seguir con mi trabajo. Muchas Gracias por tu visita.




Por último, solo nos falta averiguar el valor del retardo, para eso tenemos que ver cuánto se demora en responder el horno una vez energizamos. Vemos que el responde instantáneamente o sea que podría tener un retardo nulo. Para efectos prácticos, vamos a colocar un retardo bien pequeño para la técnica de control por Ziegler y Nichols \theta=1 y un retardo de \theta=0 para las otras dos técnicas que voy a enseñarles.

Así que en términos generales, nuestro proceso del horno está representado por la siguiente función de transferencia:

P(s)=\dfrac{53.5e^{-1 s}}{10 s +1}

Con nuestro proceso identificado podemos calcular los parámetros del controlador (k_p,t_i,t_d), para eso utilizamos cualquiera de estas tres técnicas:

 

Control PI por asignación de 2 polos reales

En esta sintonía solo utilizamos nuestra parcela Proporcional y integral, colocando la acción derivativa en cero. La idea básica de este diseño es asignarle polos a nuestro proceso para que actúe de la manera como nosotros deseamos.

  1. Seleccionamos una constante de tiempo deseada. Es decir el tiempo en que queremos que se estabilice la temperatura, por ejemplo, seleccionamos una constante de tiempo de 4 para que se estabilice el proceso en más o menos 16 segundos TsMA=4.
  2. Calculamos la frecuencia natural de nuestro sistema de forma que no tenga sobreimpulso (Como son polos iguales los que estamos asignando este sistema se conoce como críticamente amortiguado)W_n=\dfrac{3}{TsMA}=\dfrac{3}{4}=0.75
  3. Calculamos el polinomio deseado el cual contiene los dos polos iguales que estamos asignando al sistema:
    (s+W_n)^2=s^2+p_1s+p_2=s^2+(W_n+W_n)s+(Wn*W_n)
    p_1=(W_n+W_n)=(0.75+0.75)=1.5
    p_2=(W_n*W_n)=(0.75*0.75)=0.5625
  4. Por ultimo calculamos el parametro kc y ti con las siguientes formulas:
    k_p=\dfrac{P_1\tau-1}{K}=\dfrac{1.5*10-1}{53.5}=0.2616
    t_i=\dfrac{k_p*K}{P_2*\tau}=\dfrac{0.2616*53.5}{0.5625*10}=2.48

Control PI por Cancelación de Polos

La idea básica de este control es cancelar el polo de la planta (click aqui para ver una explicación del funcionamiento del controlador por cancelaciónde polos con el parámetro integral del controlador. (este controlador principalmente es para fines académicos y de simulación, no es muy recomendable aplicarlo a nivel profesional)

  1. Seleccionamos una constante de tiempo deseada. Es decir el tiempo en que queremos que se estabilice la temperatura, por ejemplo, seleccionamos una constante de tiempo de 4 para que se estabilice el proceso en más o menos 16 segundos TsMA=4.
  2. se calcula el parametro kp: k_p=\dfrac{\tau}{K*TsMA}=\dfrac{10}{53.5*4}=0.04
  3. se calcula el parametro ti: t_i=\tau

Control por Ziegler y Nichols

Ziegler y Nichols propusieron unas tablas de sintonia de controladores PID a partir de funciones de transferencias de primer orden con retardo.

Sintonia por Ziegler y Nichols

 

Controlador PID discreto

Como vamos a implementar el PID en nuestro microcontrolador PIC, debemos colocar la ley de control en tiempo discreto con un tiempo de muestreo (T) adecuado. Ziegler y Nichols propusieron determinar el tiempo de muestreo rápidamente de dos formas distintas:

  1. T<\dfrac{\theta}{4}
  2. T=\dfrac{\tau}{20}

Para nuestro caso del horno escogeremos un T=0.1 que corresponde a 100mS y siendo menor que \dfrac{\theta}{4}.

El control discreto PID viene dado por:

C(z^{-1})=\dfrac{u(k)}{e(k)}=\dfrac{q_0+q_1z^{-1}+q_2z^{-2}}{1-z^{-1}}

donde:

q_0=k_p\left [ 1+\dfrac{T}{2t_i}+\dfrac{t_d}{T} \right ]

q_1=-k_p\left [ 1-\dfrac{T}{2t_i}+\dfrac{2t_d}{T} \right ]

q_2=\dfrac{k_pt_d}{T}

Con esto, la ley de control que vamos a ingresar a nuestro PIC sale del control PID discreto (Despejando u(k))

u(k)(1-z^{-1})=q_0e(k)+q_1z^{-1}e(k)+q_2z^{-2}e(k)

u(k)-u(k)z^{-1}=q_0e(k)+q_1z^{-1}e(k)+q_2z^{-2}e(k)

u(k)=u(k)z^{-1}+q_0e(k)+q_1z^{-1}e(k)+q_2z^{-2}e(k)

Aplicando transformada inversa Z obtenemos la ecuación en diferencias:

u(k)=u(k-1)+q_0e(k)+q_1e(k-1)+q_2e(k-2)

Así, u(k) quiere decir la ley de control actual, u(k-1) es la ley de control un instante de muestreo atrás,  e(k) es el error actual (Referencia – temperatura), e(k-1) es el error un instante de muestreo atrás,  e(k-2) es el error dos instantes de muestreo atrás.

Implementación

Para implementar el control, debemos hacer uso de un MOSFET de potencia que sea capaz de aguantar la corriente del horno (4,3A), para eso se selecciono el MOSFET de combate IRFZ44N, el cual en el GATE será activado por una señal PWM a fin de poder regular la potencia del Horno (click aqui para ver entrada de PWM).

 

Para garantizar el tiempo de muestreo de 100mS, podemos hacer uso de la instrucción delay_ms(100), pero en este caso, como yo quería mayor precisión, emplee el uso del TIMER0, como lo habiamos visto en entradas pasadas (click aqui para ver entrada de TIMER).

 

Por último, quiero resaltar que el set-point o referencia será fija a 150°C, queda abierto el código para que tu puedas modificar ese parámetro haciendo por ejemplo una comunicación serial (click aqui para ver entrada de Comunicacion Serial) o colocándole algún teclado matricial (click aqui para ver entrada de teclado matricial).

En el video explico detalladamente todos los pasos y procedimientos a tener en cuenta para implementar el control PID, como por ejemplo el trabajar siempre de manera estandarizada las señales (En este caso, trabajo todo en milivoltios). Tambien explico el código y como se hace la identificación off-line. No olviden compartir este post si les gustó, delen me gusta y suscribanse a mi canal de Youtube.

Una vez termines de estudiar todo el contenido de este post puedes ver un segundo ejemplo de PID en pic en un proceso real para una planta MOTOR GENERADOR danco click aca

Código de Implementación:

A continuación se presenta el código para que lo copies y lo pegues en tu compilador y puedas reproducirlo. Recuerda que para ver el código debes compartir el contenido de este blog para que más personas se beneficien de esta información.

>>> Descargar los Archivos de PICC y PROTEUS 8 (Click aca) <<<


Si te sirvió de algo la información de la pagina, podrías invitarme a un café y ayudarme a seguir manteniendo en pie el sitio WEB. Solo cuesta $2USD y me ayudarías enormemente a seguir con mi trabajo. Muchas Gracias por tu visita.




  55 Responses to “17. Control PID con microcontrolador PIC”

  1. hola sergi saludos.. hermano me podrias atudar o guiar en una tranca que tengo…. estoy realizando el pid que tienes en tu pagina, me he propuesto realizar el pwm para controlar una bombilla de 120 volt 100watt…. el pic que utilizo es el 16f877a a 20mhz , el moc3032…..no estoy utilizando detector de cruze por cero… pero no logro conseguir la etenuacion de la iluminocidad de la bombilla…. en ciertos momentos se atenua un poco y en otros brilla mas pero no es progresivo y parpadea mucho . como puedo solucionas esto por favos ayuuda

    • Hola Emely. Te recomendaria inicialmente configurar el pwm a parte. Sin el control PID, puedes manipular el ancho de pulso con un potenciometro y ver como se comporta la luminosidad de la lampara. Cuando consigas ajustar eso, puedes incorporarlo al proyecto de PID. Yo particularmente controlaría la intensidad con un dimmer con el pic, haciendo la detección por cruce por cero y utilizando la interrupción externa del pic. Y mi variable de control seria el angulo de disparo del triac en lugar del ancho de pulso del pwm. Saludos.

  2. hola muy bueno los proyectos y muy bueno el aporte q realizas para los q estan interesados en microcontroladores tengo un problema estoy trabajando con el control pid con las entradas del sensor NTC de temperatura
    — con la declaración de variables del sensor NTC (en el código) quiero q me ayudes se lo agradecería mucho….. muy bueno el aporte

  3. Una duda disculpa, por que se estimula el horno entre el 10% y 20% de su valor nominal??

    • Es solo para identificar el proceso. En este caso por ser un proceso Lineal, no interesa mucho donde identifiques el proceso pues va a responder igual en todas partes. Para un proceso real, lo ideal es aplicar un escalón, que haga que la variable llegue mas o menos al punto donde nosotros generalmente vamos a trabajar nuestro proceso.

  4. Buenas tardes profesor. Estoy haciendo RTL en SistemVerilog, un PID para el robot LEGO, basado en su código. Sin embargo, estoy teniendo problemas para Sintetizar en Quartus II Prime, el código de valores que son de punto flotante, como la derivada e integral. Tengo la punta para tratar de introducir los valores ya mencionados como enteros. Pero no puedo ver este formulario para introducir los valores ya como enteros. ¿Me ayudas con podeira algo que decir o el ejemplo que se puede hacer? Muchas gracias.

    • Bom dia Leandro, eu não entendi muito bem teu comentario em espanhol, principalmente a parte de “Tengo la punta para tratar de introducir los valores” e “Pero no puedo ver este formulario para introducir los valores ya como enteros”, pode escrever em português sem problemas.

      Olha, o código visto nesta entrada mostra como vc pode implementar um PID, neste caso em linguagem C, mas tu podes utilizar a mesma logica em qualquer outra linguagem de programação. Podes trabalhar com variáveis do tipo float ou do tipo double no teu código. Boa sorte ai com teu projeto. Abç.

  5. Gracias por la lección. ¿Podría ayudarme a decidir cual es la mejor opción para aplicar el PID en un LEGO® Education – Robótica? O 1) ó 2) o 3)? Si usted puede ayudar a darle las gracias también.

    1)

    //*************************************************************************//
    //************* DISEÑO POR ASIGNACIÓN DE 2 POLOS REALES ****************//
    //*************************************************************************//
    /*
    TsMA=4; //Tiempo deseado en Lazo Cerrado
    Wn=3/(TsMA); //Frecuencia natural del sistema

    //Ubicación de 2 Polos reales
    P1=Wn+Wn;
    P2=Wn*Wn;

    kp=(P1*tao-1)/k; //Calculo de Kc
    ti=(k*kp)/(P2*tao); //Calculo de ti
    */

    2)

    //*************************************************************************//
    //***************** DISEÑO POR CANCELACIÓN DE POLOS *******************//
    //*************************************************************************//
    /*
    TsMA=1; //Tiempo deseado en Lazo Cerrado
    kp=(tao)/(TsMA*k); //Calculo de Kc
    ti=tao; //Calculo de Ti (Igual a la constante de tiempo)
    td=0;
    */

    3)

    //*************************************************************************//
    //***************** SINTONIA POR ZIEGLER y NICHOLS *******************//
    //*************************************************************************//

    kp=(1.2*tao)/(k*theta);
    ti=2*theta;
    td=0.5*theta;

    • los 3 pueden funcionarte perfectamente, va a depender mucho del modelado de tu proceso. Yo personalmente me inclino más por el diseño entonces prefiero la asignación de polos. Pero son factores que tu debes experimentar. Saludos.

  6. muy buen trabajo gracias por compartirlo

  7. Hola de nuevo Sergio. Sabes que avanze un poco en la realizacion de mi proyecto y tengo una duda y tendria todo listo para terminarlo por completo. Le quiero poner un SETPOINT variable con un POTE obvio y lo plantie asi al codigo:

    #INCLUDE
    #DEVICE ADC=10
    #USE DELAY(CLOCK=4000000)
    #FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
    #include
    //Configura direccion de memoria de los puertos A,B,C,D
    #BYTE PORTA= 5
    #BYTE PORTB= 6
    #BYTE PORTC= 7
    #BYTE PORTD= 8
    int veces=39 ,seg=0;
    int16 adc,control=0;
    int16 adc2;
    int sp=0;
    float yM=0,e=0.0,e_1=0.0,e_2=0.0,u=0.0,u_1=0.0;
    float kp,ti,td,q0,q1,q2,T=0.1;
    float k=53.5,tao=10.0,theta=1.0;
    float TsMA,Wn,P1,P2;

    //Con esta rutina de desbordamiento del timer 0
    //Hago el conteo del tiempo de muestreo
    #INT_RTCC //Rutina de interrupción por RTCC
    RELOJ()
    {

    VECES–; //Decremento variable veces
    SET_RTCC(246); //Cargo el timer con 246
    IF(VECES==0) //La variable veces se carga con 39 y el timer con 246
    { //para que entre a la interrupcion cada 100 milisegundos
    VECES=39;
    seg++; //y incremente el contador ‘seg’
    }
    if(seg==1)
    {
    seg=0;
    output_toggle(pin_d0);
    //Comienzo la ley de control

    e=sp-yM;
    // Controle PID
    u = u_1 + q0*e + q1*e_1 + q2*e_2; //Ley del controlador PID discreto

    if (u >= 1023.0) //Saturo la accion de control ‘uT’ en un tope maximo y minimo
    u = 1023.0;

    if (u <= 0.0)
    u = 0.0;

    control=u;

    //Retorno a los valores reales
    e_2=e_1;
    e_1=e;
    u_1=u;

    //La accion calculada la transformo en PWM
    set_pwm1_duty(control);

    }
    }
    void main()
    {
    set_tris_c(0);
    set_tris_d(0);
    setup_timer_2(t2_div_by_4,249,1); //Configuracion de Timer 2 para establecer frec. PWM a 1kHz
    setup_ccp1(ccp_pwm); //Configurar modulo CCP1 en modo PWM
    set_pwm1_duty(0); //Dejo en cero la salida PWM

    setup_adc_ports(sAN0); //Configurar ADC (Lectura de temperatura)
    setup_adc(adc_clock_internal); //Reloj interno para la conversion analoga digital)
    set_adc_channel(0); //Seleccionar Canal 0 para sensor de Temperatura

    set_adc_ports(sAN1);
    setup_adc(adc_clock_internal);
    set_adc_channel(1);

    SET_RTCC(246); //Cargo el TIMER0 con 243
    SETUP_COUNTERS(RTCC_INTERNAL, RTCC_DIV_256); //Configuro el TIMER0 con prescaler 256

    ENABLE_INTERRUPTS(INT_RTCC); //Habilito interrupcion por TIMER0
    enable_interrupts(GLOBAL); //Habilito las interrupciones a nivel global

    LCD_INIT(); //Inicializo el LCD
    LCD_PUTC("\f"); //Limpio el LCD

    //*************************************************************************//
    //************* DISEÑO POR ASIGNACIÓN DE 2 POLOS REALES ****************//
    //*************************************************************************//
    /*
    TsMA=4; //Tiempo deseado en Lazo Cerrado
    Wn=3/(TsMA); //Frecuencia natural del sistema

    //Ubicación de 2 Polos reales
    P1=Wn+Wn;
    P2=Wn*Wn;

    kp=(P1*tao-1)/k; //Calculo de Kc
    ti=(k*kp)/(P2*tao); //Calculo de ti
    */
    //*************************************************************************//
    //***************** DISEÑO POR CANCELACIÓN DE POLOS *******************//
    //*************************************************************************//
    /*
    TsMA=1; //Tiempo deseado en Lazo Cerrado
    kp=(tao)/(TsMA*k); //Calculo de Kc
    ti=tao; //Calculo de Ti (Igual a la constante de tiempo)
    td=0;
    */
    //*************************************************************************//
    //***************** SINTONIA POR ZIEGLER y NICHOLS *******************//
    //*************************************************************************//

    kp=(1.2*tao)/(k*theta);
    ti=2*theta;
    td=0.5*theta;

    //*************************************************************************//

    // Calculo do controle PID digital
    q0=kp*(1+T/(2*ti)+td/T);
    q1=-kp*(1-T/(2*ti)+(2*td)/T);
    q2=(kp*td)/T;

    while(1)
    {

    adc=read_adc(); //Leer ADC
    yM=adc*5000.0/1024.0;

    adc2=read_adc();
    sp=adc2*5000/1024

    //Muestra mensajes en LCD
    lcd_gotoxy(1,1);
    printf(lcd_putc,"Temperatura: %f C",yM/10);
    lcd_gotoxy(1,2);
    printf(lcd_putc,"SetPoint: %2.2f C ",sp/10);
    lcd_gotoxy(1,3);
    printf(lcd_putc,"Error: %2.2f C ",e/10);
    lcd_gotoxy(1,4);
    printf(lcd_putc,"PWM(bits): %ld ",control);

    }
    }

    El tema es que no puedo individualizar las entradas analogicas, o sea separar la entrada del LM35 y la entrada del POTE porque el PIC me toma las 2 juntas y al regular el pote se regula temperatura y el brillo de las lamparas, una macana, pero es asi.
    Ayudame porfa con esto mas y creo que ya termino.
    Y gracias por tu codigo y publicaciones que tanto me ayudaron hasta ahora a mi y a unos amigos que te recomende, jaja

    • Hola IRRA, bueno viendo el código que me mandaste, en realidad es mi código, solo adicionaste la lectura del potenciometro. Tu error es bastante notorio, una recomendación es darle un vistazo a la entrada donde explicamos la lectura análoga – digital en el siguiente link: http://wp.me/p5P46A-7K
      Pues estás configurando erroneamente los puertos análogos. La forma correcta seria hacerlo asi, en una sola instrucción los puertos AN0 y AN1 (en formato Hexadecimal):

      Y cuando vas a leer los datos, debes primero especificar que puerto análogo deseas leer.

      Con eso podrías solucionar tu problema. Inténtalo para ver como te corre. Saludos y éxitos en tu proyecto.

      • Hola de nuevo Sergio, y gracias porque lo que me pasaste me sirvio a la perfeccion.
        Pero no solo te escribo para agradecerte, sino porque TENGO UN INCONVENIENTE.
        Resulta que asi como me lo diste al codigo unido al mio funciona bien como dije antes, se puede variar el SETPOINT desde el POTE , el SENSOR LM35 tambien lee las temperaturas y se realiza el CONTROL PID correspondiente, estaria casi todo bien digamos y probado todo en la VIDA REAL.
        Pero lo malo es que el SETPOINT se varia solo sin que yo mueva la perilla del POTE. Se varia unos cuantos grados para arriba y para abajo no manteniendose fijo, yendo y volviendo a ese valor definido, lo cual al ser un SETPOINT no resulta estar bien. Para mi algo tiene que ver la interrupcion o los tiempos DELAY entre lecturas.
        Yo te queria consultar si podes ver el codigo que te mando y darme o ayudarme a encontrar una solucion. Te agradezco de antemano toda tu ayuda y amabilidad y simplemente seria darle esa solucion a mi proyecto y ya estaria completo y lindo para un 10, jaja.

        • Hola Irra, el problema que cuentas, es más de hardware que de software. Para que no tengas ese problema, reemplaza tu potenciometro, por un trimer (click aqui para ver imagen), que es un potenciometro pero de precisión, y este no va a variar como varia tu potenciometro. De seguro con esto puedes mejorar mucho tu problema.Comenta cualquier cosa. Saludos.

  8. Hola Sergio, primero que nada, decirte que tienes un blog, muy completo y con información muy útil, el motivo de mi pregunta es la implementación de un control PID, usando el sensor DS18B20, quiero controlar la temperatura de un foco de 75W, mi duda es ¿Cómo puedo modelar el foco? para posteriormente utilizando alguno de los métodos que muestras obtener las constantes del PID, cabe mencionar que el control del foco lo estoy haciendo usando la técnica de control por fase para realizar una “PWM en AC”, de antemano agradezco tu atención.

    saludos

    • Alan tienes que aplicar técnicas de identificación, ese es un tema que me han pedido bastante, pero no he tenido el tiempo de hacer las clases. Basicamente debes hacer lo mismo que se hizo con el OVEN, lo que debes hacer es mandar una señal con el PWM a tu foco, ojala cerca de la región que quieres trabajar, es decir si por ejemplo mandando un PWM del 60% tu foco hace que tu temperatura llegue digamos a 30°C y esa es más o menos la temperatura en la que deseas trabajar, seria perfecto. Asi al aplicar un escalón del 60% debes tomar el tiempo y la temperatura cada determinado tiempo, digamos cada segundo o dos segundos he ir almacenando esos datos, para al final generar la grafica de respuesta que se vió en el ejemplo del Oven, asi obtienes la ganancia, la constante de tiempo y el tiempo muerto con los cuales posteriormente podrás obtener los parametros del PID. En sintesis es basicamente hacer lo mismo visto en el ejemplo, solo que en tu caso es un bombillo.
      Estoy preparando un video practico de un proceso simple real con PID, donde voy a mostrar como modelar el sistema y controlarlo con el PID, debo estar subiendo ese video en enero, pues ya me han preguntado bastante sobre este tema, y espero con esa practica quede un poco más claro el procedimiento. Saludos y muchos éxitos.

      • Hola Sergio, gracias por tu ayuda… entonces si entendí bien, para simular el proceso, puedo configurar el OVEN con los mismos parámetros q se vieron en el video y únicamente cambiaría la entrada escalón de acuerdo a la temperatura de trabajo que deseo ¿verdad?

        • Bueno, para configurar el OVEN igual a un bombillo, entra a las configuraciones y colocale 70W al oven, tambien debes saber cual es la máxima temp que alcanza el bombillo cuando lo dejas totalmente encendido y con base en ello tienes que hacer que el oven cuando esta totalmente encendido tambien llegue a la misma temperatura, eso lo logras modificando el voltaje del oven, poniendolo más bajo, talvez de esa forma puedas simularlo.

  9. Hola, SERGIO. Che la verdad que te pasaste con tu post del PID y con los otros tambien que voy viendo. Yo quiero hacer casi lo mismo que vos hiciste que tanto me ayudo pero agregarle un COOLER o ventilador y que este funcione como enfriador en el sistema.
    Se que tendria que armar otro control PID para el motor del cooler que es de continua de 12V, por eso te queria consultar si por algun lugar viste otro post tuyo o ajeno en donde realizen lo que te comente o algo parecido. Y si vos me podes responder obvio, como obtener una realimentacion de un motor DC del COOLER? de esa forma aplicarle el PID, asi como hiciste con el HORNO.
    PD: Yo quiero usar un sensor LM35, un COOLER y una LAMPARA DE 12.

    • Irra, gracias por visitar la pagina, que bueno que te haya gustado. La verdad no conozco una pagina donde muestre algo de lo que quieres hacer, y no se como puedas obtener facilmente la realimentación del cooler. Yo veo tu problema más en la linea de un problema de control multivariable, (tendras que tener un poco más de conocimiento de control), propiamente tu problema seria un sistema MISO (Multi-Input Single Output, multiples entradas y una salida) tus dos entradas serian el cooler y la lampara, y tu salida seria la temperatura, lo que indica que es un sistema facil de controlar, pues tienes más grados de libertad para manipular tu temperatura. Es decir que solo debes realimentar con el LM35 los 2 PID. Primero debes identificar la temperatura con el bombillo (funcion de transferencia) y luego con el cooler, tendras entonces dos FT, una que relaciona la entrada 1 con la salida, y la otra la entrada 2 con la salida. Te recomiendo des una estudiada en control multivariable, para que hagas tu proyecto. Saludos.

  10. parcero.

    sin comentarios, la verdad es lo mismo que te dije en el control predictivo era lo que estaba buscando, muy completo el vídeo, muy completa la explicacion.

    solo resta por decir gracias.

    Att: emerson palacio

  11. Hola Sergio, como puedo cambiar el valor del setpoint y poder mostrarlo en la pantalla LCD? por ejemplo un setpoint de 100.
    De antemano gracias por la información.

  12. QUE TAL SERGIO, PRIMERO QUE NADA TE FELICITO POR TU BLOG, ESTA MUY BIEN PENSADO Y MUY COMPLETO… ESTE PROYECTO EN PARTICULAR ESTOY REALIZANDOLO PARA DESPUES ADAPTARLO A CON CONTROL DE MOTOR PWM; PERO UTILIZANDO EL PIC18F2550, AUNQUE NO ENTIENDO PORQUE NO PUEDO HACERLO FUNCIONAR CON EXITO. YA CAMBIE LOS PARAMETROS DEL ENCABEZADO, SIN EMBARGO SIGUE SIN DARME RESPUESTA, PODRIAS AYUDARME? AQUI TE DEJO MI ENCABEZADO PARA VER SI TU ME PUEDES SEÑALAR EL ERROR, SI ES QUE ÉSTE SE ENCUENTRA EN AHI:
    #INCLUDE
    #DEVICE ADC=8
    #USE DELAY(CLOCK=4000000)
    #FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
    #include
    //Configura direccion de memoria de los puertos A,B,C,D
    #BYTE PORTA=0xF80
    #BYTE PORTB=0xF81
    #BYTE PORTC=0xF82

    basicamente es todo lo que eh cambiado en el programa, me guie por un post de otro usuario en donde te respondiste que unicamente teniamos que cambiar el encabezaddo…
    Te agradesco de antemano, espero puedas ayudarme.

    • Hola Miguel. Para ese PIC que es más pequeño, pues tiene menos puertos, está correcto tu ebcabezado.
      #INCLUDE<18F2550.h>
      #DEVICE ADC=8
      #USE DELAY(CLOCK=4000000)
      #FUSES XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
      #include
      //Configura direccion de memoria de los puertos A,B,C,D
      #BYTE PORTA=0xF80
      #BYTE PORTB=0xF81
      #BYTE PORTC=0xF82

      Debes ver como no tienes puerto D, debes cambiar la posicion del LED, del ejemplo, o simplemente coloca esas lineas en comentario.
      //output_toggle(pin_d0);
      //set_tris_d(0);

      tambien se modifica la forma como se configura la entrada analoga del PIC, que en este caso estamos usando solo el puerto A0 como entrada analoga:
      setup_adc_ports(AN0);

      Saludos

  13. Hola Sergio muy lindo tu trabajo, quería consultarte como haces en mikroc el desbordamiento del timer 0. Saludos y éxitos.

    • Hola Cristina, la verdad nunca he usado mikroc, entonces no sabría responderte, imagino yo debe ser muy similar al picc, de igual forma, para generar el periodo de muestreo puedes hacerlo también con retardos o con delays, que también te podría funcionar perfectamente.

  14. Sergio buen dia molestandote de nuevo.
    Disculpa la pregunta. Que condiciones empleas para caracterizar una resistencia AC, me refiero a temperatura, humedad, etc. Lo que sucede es que mi proyecto es una cuna termica de calor radiante, el sensor de temperatura que mide la temperatura de piel del bebe esta a un metro de distancia de la resistencia calefactora y se encuentra abierto, lo que implica que las condiciones de la temperatura ambiente le afectan, por eso preguntaba, si cuando tu caracterizas una resistencia calefactora, empleas algunas condiciones para hacer la caracterizacion los mas precisa posible. DE ANTEMANO GRACIAS.

    • Para indentificar el modelo de cualquier proceso existen diferentes técnica. En este caso hicimos una identificación del horno a través de una curva de reacción. Lo más conveniente es que comiences a leer y estudiar sobre identificación de sistemas. Puedes emplear un metodo parametrico para determinar tu modelo. Lo ideal es que lo identifiques en un punto de operación y si tienes la posibilidad de leer las otras variables como la temperatura exterior o la humedad, puedes realizar un controlador FeedForward. La tematica de identificación de procesos es bien interesante y estoy pensando incluirla en el blog. Es mucho tema que me gustaria abordar aqui, pero lastimosamente no tengo disponibilidad exclusiva para montar todo. En unos años espero tener el blog con bastante información. Saludos.

  15. Hola sergio. Una pregunta
    Como obtendrias la ganacia K del sistema para una resistencia calefactora de CA dado que como sabemos la ganancia K se calcula con la formula: k=(Yfinal-Yinicial)/(Ufinal-Uinicial).
    Como obtendria los valores de Ufinal y Uinicial, hablando de una resistencia calefactora que se le aplica Corriente Alterna.
    Gracias

    • Hola Julio. Ese calculo es sumamente parecido con el ejemplo que vimos en esta entrada. En tu caso como tienes una resistencia que digamos está conectada a 120VAC. Tu necesitaras regular la potencia de tu resistencia, para eso lo mas conveniente es usar un Relé de Estado solido, que en la entrada sea de 3VDC – 32 VDC y que la salida sea de 24-380 VAC. Este rele de estado solido debes conectarlo en Serie en tu resistencia y NUNCA en paralelo. Ahora con la salida del PWM del micro lo conectas en la entrada del relé de estado solido. Y por programación puedes colocarle al micro que envie un PWM (1Khz por ejemplo) con un duty cicle del 20%. De esa forma el Relé de estado solido va a swichear rapidamente regulando el voltaje q entra en tu resistencia. Aqui tu Ufinal seria 20 y tu Uinicial=0. De hecho en este ejemplo se podia haber hecho lo mismo con el Mosfet, simplemente pondria el PWM en un ciclo de dureza continuo (duty cicle) en 20% por ejemplo y calculaba la K, para este caso ya no se trabajaria con el U en voltaje, si no que se trabajaria en porcentaje (Ufinal=20, Uinicial=0). Saludos.

      • Muy amable por tu asesoria sergio, es que aun sigo con mi proyecto y no me queda, pero voy a obtener el valor de K asi como me comentas. De antemano mil gracias

  16. felicidades sergio, excelente aporte.
    Oye mira te queria hacer unas preguntas, estoy desarrollando un control de temperatura de una resistencia calefactora de CA.
    1.- si le aplico un pwm entre el 10 y 20% a esta resistencia alcanzo un temperatura maxima de 36,4 °C, pero yo requiero poder controlarla hasta 39 °C, algo que solo consigo si le aplico el maximo pwm 100% Ciclo de Trabajo, ¿debere caracterizarla aplicando Uinicial=0% y Ufinal=100%? utilizo un pwm de frecuencia igual a 3 Hertz.
    2.- tu que me recomiendas¿Controlarla controlarla con un PWM bajo por ejemplo 1Hz o un pwm alto como segun comentaste anteriormente 1000 Hz?
    3.-segun he leido, se debe aplicar entre el 10 y el 20% del valor nominal para caracterizarla, significa que debo aplicar entre el 10 y 20% del ciclo de trabajo de mi pwm para caracterizarla?
    4.- el valo de la K se obtiene K=(Yfinal-Yinicial)/(Ufinal-Uinicial), los valores de Ufinal y Uinicial tomando el porcentaje de ciclo de trabajo por ejemplo: Ufinal=15% y Uinicial=0%, o se toma la enegia que le llega a la resistencia durante el lapso de tiempo que se aplican los impulsos por pwm, es decir segun la formula U=Voltaje*Corriente*tiempo?

    De antemano mil gracias

    • Hola Julio, gracias por visitar la pagina y por aportarle al lector joao un codigo PID. En cuanto a tus preguntas te cuento algo. Es bastante preocupante que tu resistencia llegue a la temperatura que deseas al 100% del PWM, eso demuestra que tu resistencia NO está dimensionada para tu proceso y lo más recomendable sería cambiarla. Pues piensalo asi, no tiene sentido colocar un controlador para que el trabaje todo el tiempo en 100%, para eso, simplemente conectas la resistencia directamente. Obviamente perderas todas las ventajas de un control por realimentación, como es el caso del rechazo de perturbaciones, pero de igual forma ese rechazo será imposible pues tu control no tiene más acción para rechazar nada.

      2. Yo trabajaria con un PWM de 1Khz.

      3. Si ya sabes el punto de trabajo donde quieres trabajar, puedes identificar el proceso en ese punto, osea en tu caso seria un escalón de 0° hasta 39°.De esa forma tendras un modelo linealizado en el punto que vas a trabajar.

      4. Uinicial será 0y el Ufinal será el voltaje que le entre a la resistencia en el escalón de 39° de temperatura, igual que en el ejemplo. Donde y es temperatura y u es voltaje.

      Espero puedas realizar tu control. Un saludo y muchos éxitos.

  17. Que es convertir este programa para mikroC

    • Olá João, na real eu nunca utilicei o mikroC, mas acho que não deve ser muito diferente do PICC, a ideia é utilizar a mesma logica, só que utilizando os comandos do mikroC. Obrigado por visitar o Site, tomara tu consigas modificar o codigo para o mikroC. Grande abraço.

    • ola Joao, te envio el codigo que implemente en mikroC pro for pic, funciona al cien. saludos
      el codigo es el siguiente:

      //******************************************************************************************************************
      int valor, control; //Variables para lectura de ADC y señal de Control a modulo CCP
      float coef_a,coef_b,coef_c; //Constantes para parámetros de controlador PID
      float TEMPERATURA_LIMITE; //Referencia de Temperatura
      float rt,eT,iT,dT,yT,uT,iT0,eT0; //Variables de controlador PID
      float max1,min1; //Variables para anti-windup

      void main()
      {
      ADCON1=0b10000000;
      TRISC=0;
      TRISA=0xff;

      min1=0.0;
      max1=1000.0;
      iT0=0.0;
      eT0=0.0;
      coef_a=0.1243;
      coef_b=0.0062;
      coef_c=0.6215;

      TEMPERATURA_LIMITE=800.0; //Set Point r(kT)= 120°C
      PWM1_Init(1000);
      PWM1_Set_Duty(0);
      PWM1_Start();

      while(1)
      {
      valor= ADC_Read(0); //Leer ADC
      yT=5000.0*valor/1024.0; //Escalizar señal de salida y(kT)
      rT=TEMPERATURA_LIMITE;
      eT=rT-yT; //Calcular senal de error e(kT)
      iT=coef_b*eT+iT0; //Calcular termino integrativo i(kT)
      dT=coef_c*(eT-eT0); //Calcular termino derivativo d(kT)
      uT=iT+coef_a*eT+dT; //Calcular senal de control u(kT)
      if (uT>max1)
      { //Anti-windup
      uT=max1;
      }
      else
      {
      if (uT<min1)
      {
      uT=min1;
      }
      }
      control=uT;
      PWM1_Set_Duty(control);
      iT0=iT;
      eT0=eT;
      delay_ms(100); //Periodo de muestreo T=0.1s
      }
      }
      //******************************************************************************************************************

      • solo una observacion, essolo el codigo para el pid,no despliega valores en un LCD. Espero te sirva dealgo. saludos

  18. Hola oye poseo el modelo de un motor dc pero solo en velocidad al parecer al integrar se obtiene posición, pero como sintonizas porque estaba viendo y la respuesta en posición al integrar es una linea recta que método usarías tu?

    • Hola Nelson. Al agragar una integral a tu modelo para obtener la posición. Tu modelo se transforma en un modelo de tipo 1, debido a la acción integradora y tu respuesta va a ser una linea recta en forma de rampa. Si tu idea es que tu sistema siga un escalón, simplemente por causa del principio del modelo interno que vimos en esta entrada, puedes sintonizar un controlador proporcional únicamente. Claro está, si lo deseas puedes aplicar un PI, claro que no es necesario dado que tu proceso ya tiene la acción integradora, para este caso, yo sintonizaría un PI por asignación de polos. Pero vuelvo y te digo, la forma más sencilla de controlar procesos integradores es colocando una simple ganancia en el controlador (Control Proporcional). Saludos.

  19. Gracias por tu pronta respuesta.

    Esperamos el vídeo que comentas sobre adquirir datos del sistema para obtener el modelo.

    ¡Mucha suerte y mil gracias!.

  20. Un saludo Sergio.

    Requiero hacer el control PID, pero en lugar de utilizar un Mosfet utilizare un Triac, ya que el control sera por angulo de fase.

    Como sé que la tensión de C.A. es de 127 Volts, entonces, para modelar la planta voy a aplicar un escalón al 19% de la tension de C.A. (127 Volts) que seria 24 Volts de C.A.

    ¿Esto es correcto esto?. ¿Se puede escalar de esta manera la tenscion de C.A. para el modelo de la planta?.

    • Hola Manuel, gracias por visitar la página. Con respecto a tu pregunta no puedes hacerlo como estas comentando. Como estas trabajando con CA, y como vas a usar un Triac, aqui tu triac en tu circuito de potencia, está funcionando como un Switche, y él deberia ser activado por la señal de PWM del PIC. Es decir que si aplicas una señal del PWM máxima, el triac estaria como switche abierto y dejaria pasar todo el voltaje. Ahora, si vas a aplicar el escalón de 19%, debes es aplicarlo en tu PWM y no en el voltaje. Es decir, tu voltaje siempre será el mismo 127V, la regulación que estas haciendo va a venir desde el triac, cuando le mandas al triac un PWM del 19%, el solo va a permitir que el voltaje entre en ese corto periodo de tiempo a tu sistema, asi tu variable solamente va a variar segun el voltaje limitado que le estas ingresando. En ese tiempo puedes tomar datos y generar la curva que represente la dinamica del proceso, o aplicar alguna tecnica de identificación. Puedes visitar la sección donde explico el PWM. Yo por ejemplo, crearía un PWM de 1Khz, asi mi valor de PWM para ser máximo segun explico aqui(http://controlautomaticoeducacion.com/15-pwm-ancho-por-modulacion-de-pulso/) seria
      set_pwm1_duty(1000);
      ahora para realizar la identificación, simplemente colocaria en el ciclo infinito un porcentaje del valor máximo, por ejemplo:
      set_pwm1_duty(200);
      y tomaria los datos de mi variable. Más adelante haré un video enseñando a hacer una tarjeta de adquisicion de datos, para que aprendan a tomar datos con el pic y a obtener el modelo. Abrazo.

  21. Un saludo amigo, muy didáctico tu post y el video en YouTube.

    Solo me queda una duda:

    Según la configuración del horno, el acondicionamiento de señal y el escalamiento de la lectura del ADC, el valor de yM obtenido es 10 veces mayor a la temperatura del horno, la variación de 25 °C a 132 °C, provocaría una variación en yM de 250 a 1320, según esto el valor de K sería K=(1320-250)/(2-0)=535 en lugar de 53.5 que usas en el programa del microcontrolador.

    • Hola Edgar. La identificación de la planta consiste en determinar la ecuación matemática que describa el comportamiento dinámico del sistema independientemente del método o del dispositivo que vamos a usar para controlar. Es decir, que la identificación es una cosa y el escalamiento de la lectura ADC es otra. En este ejemplo, estoy intentando modelar el comportamiento de la variable temperatura y no la señal del sensor (que está en mili-voltios), siendo así, se debe colocar 132 grados celcius – 25 grados celcius para que me de la ganancia del sistema en grados celcius por voltio. Osea que si mi sistema le aplico un voltaje con en el ejemplo de 2 voltios, el horno debe llegar a 132 grados celcius en estado estacionario partiendo desde el reposo (25 grados) y no a 1320 grados. Saludos y gracias por visitar la pagina.

  22. Gracias por responder Sergio C.

    Solo una pregunta en el minuto 19:42 del video hablas acerca del retardo θ, al cual diste un valor de 1 por lo rápido que gráfico la respuesta en el proteus, mi pregunta:

    ¿En un sistema real ese θ quiero suponer que lo obtengo apartir de energizar el sistema y hasta cuando termina θ?.

    Una disculpa Sergio, quizás no capto las ideas tan rápido, pero tampoco me gusta quedarme con incógnitas. Me sera de gran ayuda el saberlo..

    • Hola Manuel, efectivamente en la simulación para no hacerla muy larga el retardo θ es de 1. Ahora para un sistema real, no va a ser asi, principalmente en procesos tan lentos como la temperatura. Entonces, te doy el ejemplo de un horno real. Si tu tienes un horno que esta a temperatura ambiente 25°C, tu lo energizas y comienzas obviamente a tomar los datos de temperatura cada determinado tiempo (Tiempo de muestreo) por decir algo comienzas a tomar cada 5 segundos datos de temperatura. Podrás observar que al cabo de los primeros 5 segundos el horno continuara en 25°C, luego a los 10 segundos, posiblemente seguirá en 25°C, luego a los 15 segundos continua en 25°C, luego a los 20 segundos ves que la temperatura subió a 26°C, osea que ya comenzó a moverse debido a que energizaste el horno. Osea que el horno se demoró 20 segundo en comenzar a reaccionar después de energizado, quiere decir que tiene un θ=20 segundos. En otras palabras el retardo es el tiempo que le toma al proceso en comenzar a reaccionar después de que tu lo estimulas, por ejemplo en este caso después de que tú lo enciendes.

      En la industria hay muchas variables que podemos controlar, y muchas veces vamos a tener proceso que responden instantáneamente, es decir que tendrán un θ=0.

      • Muy buena explicación.

        Es justa la respuesta a mi pregunta, seguimos atentos a tu paguina y publicaciones para seguir aprendiendo de ti. Gracias.

  23. Un saludo Sergio Castaño, tienes unos vídeos excelentes y muchas gracias por compartirlos. Yo soy estudiante y me son de gran ayuda ahora que empiezo a estudiar acerca del control PID.

    Me gustaría saber si puedes compartir el vídeo en físico de un PID de temperatura implementando un microcontrolador PIC.

    • Hola Manuel, gracias por visitar mi pagina. Que bueno que te sirvan los videos. Por ahora montar uno físico me queda imposible, pues no dispongo de mucho tiempo libre y en este momento ando con otros proyectos. Ya anteriormente he montado varios PID en microcontroladores, he incluso coloque algunos en procesos industriales. A mi siempre me ha funcionado y trabaja muy bien. Monta el tuyo y practica 🙂 Una recomendación importante es en cuanto al Sensor, te debes antes que nada cerciorarte de obtener una buena medición de tu proceso, porque si no tienes una buena medición, tu controlador se va a enloquecer intentando controlar la variable. Saludos y muchos éxitos.

      • Gracias Sergio, sigo de muy atento esta página con tus publicaciones. Entiendo tu respuesta. Gracias nuevamente por compartir y grandes exitos.

  24. Excelente trabajo Sergio, pero tengo dos preguntas
    1.- Como sacas al ecuación de transferencia del horno
    2.- Tienes alguna información para entender un poco mas a detalle la ley de control PID discretizado indicada en el tutorial.
    Gracias y en verdad muy buen aporte.

    • Hola Gabriel, mira para la funcion de transferencia, se utiliza la grafica generada por el horno en lazo abierto, puedes ver el video a partir del minuto 17. Aqui hayas los tres parametros que necesitas. La ganancia (K), la constate de tiempo (tao) y el retardo (theta).

      La ley de control discreta se obtiene a partir de la función de transferencia discreta del PID:

      De esa ley de control discreta, debes despejar el u(k) de la ecuación y luego aplicar transformada inverza Z. Mas adelante podría hacer un video sobre esto.

 Leave a Reply

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">

(required)

(required)