INSTITUTO TECNOLGICO DE

QUERTARO

Joel Espinoza Ocaa

Control Digital
Mxico, Queretaro Qro.
LABORATORIO DE ELECTRNICA III
DEPTO. DE INGENIERA ELECTRNICA
QUERTARO, QRO. A 28 DE SEPTIEMBRE DEL 2006.

Discretizacin de un PID (el definido en tiempo continuo) y

explique como se programara en el microcontrolador.
El principio bsico del esquema de control PID es que acta sobre la
variable a ser manipulada a travs de una apropiada combinacin de
las tres acciones de control:
Accin proporcional.
Accin integral.
Accin derivativa.
Primero partimos de la accin de control PID en controladores
analgicos.

U ( s) = Kp E ( s) +

Ki
E ( s) + Kd s E ( s)
s

As la accin de control seria.

U ( s)
Ki
= Kp +
+ Kd s
E ( s)
s
Ahora mostraremos dos formas para discretizar esta ecuacin.
Primera forma:
Sabemos que el sistema en general es:

Donde
Notaciones
r = seal de referencia

X = comparador

e = seal de error

C = controlador

u = seal de control

F = sistema a controlar

y = respuesta del sistema H = sensor

Ahora tomaremos que el sensor [H(s)=1]

Por tanto el error en el tiempo:

e(t ) = r (t ) y (t )
Primer Discretizacin:

Para la diferenciacin (Diferencia hacia atras)

u (k ) =

de(t ) 1
= (e(t ) e[(k 1)T ]
dt
T

U ( z ) (z 1 )
=
E (z)
Tz

Para la integracin (Integracin rectangular hacia adelante)

u ( k ) = u [(k 1)T ] + Te ( kT )
U (z)
Tz
=
E (z)
( z 1)
As la ecuacin de diferencias que se resolveria seria la siguiente:

kd
u ( k ) = Kp e(k ) + Ki[u (k 1) + T e(k )] + (e( k ) e(k 1) )
T
Donde desarrollamos y nos queda:

u (k ) = a0 e(k ) + a1e(k 1) + a2u (k 1)

Donde:

a 0 = Kp + ki T +
a1 = kd T
a 2 = ki

kd
T

Segunda Discretizacin:
Ahora analizaremos cada termino, para la integracin esta bibliografa
toma la integracin basada en Newton-Coates, Lo cual se traduce
simplemente algoritmo rectangular de integracin.

Para la integral

Ahora analicemos que la forma en que se tomara la integracin en

forma de promedio es decir:

Kt

T k
ki e ( t ) dt = ki {e [( j 1) T ] + e ( jT ) }
2 j =1
0

kd

Para la derivacin.

de(t )
e(kT ) e[(k 1)T ]
= Kd

dt
T

Ahora lo que hacemos es sumar todas las partes de la seal de

control. La cual llamaremos u (KT )

u ( kT ) = Kp e ( kT ) + ki

T k
e ( kT ) e [(k 1 )T ]
{e [( j 1) T ] + e ( jT ) } + Kd

T
2 j =1

Ahora lo que sigue es discretizar la seal u (KT )

Lo primero que analizaremos por partes (Proporcionar, integral y

diferencial) en el momento de control actual.
Ahora tenemos que aclarar que necesitamos pensar en lo que
necesitamos una seal de control para el momento k. Por eso
necesitamos al momento kT quitarle la anterior seal de control
Por lo tanto podemos deducir la ecuacin de diferencias de la
siguiente forma: donde KT = k

Proporcional

P = Kp [e ( kT ) e (( k 1)T )]
P = Kp [e ( k ) e (k 1 )]

Integral

I = Ki
I = Ki

T
[e ( kT ) e (( k 1)T
2

)]

T
[e ( k ) e (k 1 )]
2

Derivativa

D =

D =
D =

Kd
T

{[e ( kT ) e (( k

Kd
T

1)T )] [e (( k 1)T ) e ((k 2 )T ))]}

{[e ( k ) e (k

1 )] [e (( k 1 ) ) e (k 2 )]}

Kd
{e ( k ) 2 e ( k 1) + e ( k 2 )}
T

Por tanto

u ( k ) u (k 1 ) =
Kp[e( k ) e( k 1)] + ki

T
[e(k ) + e(k 1)] + Kd [e(k ) 2e(k 1) + e(k 2)]
2
T

Esta seria la ecuacin de diferencias que se programara en un

microcontrolador.
Ahora podemos reducir la ecuacin factorizando cada trmino

T
Kd
+
2
T
T
Kd
a1 = Kp + Ki 2
2
T
Kd
a2 =
T
a 0 = Kp + Ki

As tendramos.

u ( k ) u (k 1 ) = a 0 e ( k ) + a 1 e ( k 1) + a 2 e ( k 2 )
Ahora necesitamos la transformada Z de la ecuacin anterior ya que
esta ecuacin seria con la cual tendramos que simular.

u(k) u(k 1) =

Kp [e( k ) e( k 1)] + ki

T
[e(k ) + e(k 1)] + Kd [e(k ) 2e(k 1) + e(k 2)]
2
T

Ahora para realizar la transformacin nos basaremos en el teorema

de desplazamiento hacia la derecha.

U(z) z1U(z) = (1 z1) U(z) =

T
Kd
E ( z ) + z 1 E ( z ) +
E ( z ) 2 z 1 E ( z ) + z 2 E ( z )
2
T
T
Kd
= Kp 1 z 1 E ( z ) + ki 1 + z 1 E ( z ) +
1 2 z 1 + z 2 E ( z )
2
T
= Kp E ( z ) z 1 E ( z ) + ki

Para la ultima parte de la ecuacin anterior primero hacemos:

2 1 z 2 2 z + 1 ( z 1)( z 1) ( z 1)
1 2z + z = 1 + 2 =
=
=
z z
z2
z2
z2
1
z 1
z 1
1 z 1 = 1 = =
z
z z
z
1

1+ z
1 z 1

1
z 1
z +1
+
z = z z = z = z +1
=
1
z 1
z 1
z 1
1

z
z z
z
1+

Ahora finalmente de la ecuacin despejamos U (z )

U ( z)
T 1 + z 1 Kd z 1
+
= Kp + ki

E ( z)
2 1 z 1 T z

U ( z)
T z + 1 Kd z 1
= Kp + ki
+

E( z)
2 z 1 T z
U ( z)
=
E ( z)

Kp z (z 1) + ki

U ( z)
=
E( z)
U ( z)
=
E( z)

T
Kd
2
z (z + 1) +
( z 1)
T
2
z ( z 1)

Kp z 2 z + ki

T 2
Kd 2
z +z +
z 2z +1
2
T
z ( z 1)

Kp z 2 Kp z + ki

T 2
T
Kd 2 Kd
Kd
z + ki z +
z
2z +
2
2
T
T
T
z ( z 1)

T Kd
T
Kd Kd

z 2 Kp + ki
+
+ z Kp + ki + 2
U ( z)
2 T
2
T T
=
E( z)
z ( z 1)

Donde

T
Kd
+
2
T
T
Kd
a1 = Kp + Ki 2
2
T
Kd
a2 =
T
a 0 = Kp + Ki

Un diagrama de control es mostrado a continuacin. Donde el

controlador no solo depende de las tres ganancias del controlador
PID, sino tambin del periodo de muestreo.

Discretizacin del PID

La idea es utilizar este algoritmo de control para la programacin de
un microcontrolador:
La ecuacin de
microcontrolador.

diferencias

que

se

programara

en

un

Ahora podemos reducir la ecuacin factorizando cada trmino, As

tendramos.

u ( k ) u (k 1 ) = a 0 e ( k ) + a 1 e ( k 1) + a 2 e ( k 2 )
Por lo tanto podramos decir que, la accin de control por lo tanto nos
indica que es:
Una constante por el error actual mas la seal de control
anterior a la actual, mas dos seales anteriores. Mas la accin
de control anterior.

u ( k ) = a 0 e ( k ) + a 1 e ( k 1) + a 2 e ( k 2 ) + u (k 1 )
Para la programacin del microcontrolador introduciramos por
un teclado matricial las constantes Kp, Ki y Kd, posteriormente
simplemente se realizan las siguientes operaciones:

T Kd
+
2 T
T
Kd
a1 = Kp + Ki 2
T
2
Kd
a2 =
T

a0 = Kp + Ki

Ahora se va a escribir en una funcin la accin de control u(k):

Del ogata:

u ( k ) = a 0 e ( k ) + a 1 e ( k 1) + a 2 e ( k 2 ) + u (k 1 )

Del Dorf:

u (k ) = a0 e(k ) + a1e(k 1) + a2u (k 1)

Donde:

T Kd
+
2 T
T
Kd
a1 = Kp + Ki 2
2
T
Kd
a2 =
T

a0 = Kp + Ki

a0 = Kp + ki T +

kd
T

a1 = kd T
a 2 = ki
OGATA

DORF

Recordemos que para seal muestreada debe de haber una accin de

control. Primero determinamos lo primordial determinar que la seal
de de control UK seria para un PWM.
Inicializacion de variables
Uk_anterior =0
Float a0 = 0
Float a1 = 0
Float a2 = 0

Void

Accion_Control(set_point,feedback){

error_k2 = error_k1;
error_k1 = error_k0;
error_k0= set_point- feedback;
uk=a0* error_k0+a1*error_K1+a2*error_K2+Uk_anterior;
uk_anterior=uk;
}

Este controlador es en base al que realiza el libro del Ogata. Sin

embargo el libro dorf propone otro con otra ecuacin de diferencias
que finalmente funciona de la misma forma, si las comparamos
simplemente el libro Ogata toma en cuenta otro error dos veces
anterior al actual. El algoritmo de control seria algo casi exactamente
igual a este.