```
%matplotlib inline
from sympy import var, Matrix, eye, init_printing, roots
init_printing()
```


```
var("a:5")
var("b:5")
var("s");
```

# Formas canónicas observador y observabilidad

Tenemos un sistema de orden $4$ con una representación de estado:


```
Ao = Matrix([[0, 0, 0, -a4], [1, 0, 0, -a3], [0, 1, 0, -a2], [0, 0, 1, -a1]])
bo = Matrix([[b4], [b3], [b2], [b1]])
co = Matrix([[0], [0], [0], [1]])
```


```
Ao
```


```
bo
```


```
co
```

La cual ya esta en la forma canónica observador, podemos obtener su polinomio caracteristico:


```
PCo = (s*eye(4) - Ao).det()
PCo
```

La matriz sistema es la siguiente:


```
MSo = (s*eye(4) - Ao).row_join(bo).col_join(-co.T.row_join(Matrix([0])))
MSo
```

y su polinomio es:


```
pMSo = MSo.det()
pMSo
```

tiene una matriz de observabilidad:


```
MOo = ((co.T.col_join(co.T*Ao)).col_join(co.T*Ao*Ao)).col_join(co.T*Ao*Ao*Ao)
MOo
```


```
MOo.det()
```

Dado este sistema, podemos transformarlo a su forma observabilidad:


```
Aob = Matrix([[-a1, -a2, -a3, -a4], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]])
beta = Matrix([[1, 0, 0, 0], [a1, 1, 0, 0], [a2, a1, 1, 0], [a3, a2, a1, 1]]).inv()*Matrix([[b1], [b2], [b3], [b4]])
bob = Matrix([[beta[3]], [beta[2]], [beta[1]], [beta[0]]])
cob = co
```


```
Aob
```


```
bob
```


```
cob
```

La cual, tiene un polinomio caracteristico:


```
PCob = (s*eye(4) - Aob).det()
PCob
```

y una matriz sistema:


```
MSob = (s*eye(4) - Aob).row_join(bob).col_join(-co.T.row_join(Matrix([0])))
MSob
```

con una matriz de observabilidad:


```
MOob = ((cob.T.col_join(cob.T*Aob)).col_join(cob.T*Aob*Aob)).col_join(cob.T*Aob*Aob*Aob)
MOob
```


```
MOob.det()
```

## Ejemplo

Tenemos el siguiente sistema:


```
from numpy import matrix
```


```
A = Matrix([[0, 1, 0], [0, 0 , 1], [0, 0, 0]])
b = Matrix([[0], [0], [1]])
c = Matrix([[-1], [0], [1]])
x0 = Matrix ([[1], [0], [0]])
```

Su polinomio caracteristico es:


```
PC = (s*eye(3) - A).det()
PC
```

Su matriz sistema es:


```
MS =(s*eye(3) - A).row_join(b).col_join(-c.T.row_join(Matrix([0])))
MS
```

y su polinomio es:


```
pMS =  MS.det()
pMS.factor()
```

su matriz de controlabilidad es:


```
MC = (b.row_join(A*b)).row_join(A*A*b)
MC
```

y su determinanate:


```
MC.det()
```

lo que quiere decir, que este sistema es controlable.

Ahora calculamos su matriz de observabilidad.


```
MO = (c.T.col_join(c.T*A)).col_join(c.T*A*A)
MO
```

y su determinante:


```
MO.det()
```

lo cual quiere decir que  es observable.

Sabemos que tenemos 3 polos en el origen, pero queremos que esten en $-1$, podemos calcular los coeficientes necesarios:


```
((s+1)**3).expand()
```

lo cual nos implica la siguiente retroalimentación de estado:


```
f = Matrix([[-1], [-3], [-3]])
```

y el siguiente sistema retroalimentado:


```
Af = A + b*f.T
Af
```


```
A.col_join(c.T)
```

pero para calcular la inyección de salida, deseamos hacerlo bajo la forma canónica observador, por lo que primero la describimos y despues calculamos el cambio de base necesario:


```
Ao = Matrix([[0, 0, 0], [1, 0, 0], [0, 1, 0]])
bo = Matrix([[-1], [0], [1]])
co = Matrix([[0], [0], [1]])
```

cuya función de transferencia será:


```
(co.T*((s*eye(3) - Ao).inv())*bo)[0].factor()
```

su matriz de observabilidad:


```
MOo = (co.T.col_join(co.T*Ao)).col_join(co.T*Ao*Ao)
MOo
```

y la matriz de cambio de base será:


```
T = MO.inv()* MOo
T
```

teniendo esto, tan solo tenemos que idear una inyección de salida.

En este caso, queremos una respuesta mas rapida, por lo que pondremos estos polos en $-10$:


```
((s+10)**3).expand()
```

por lo que nuestra inyección de salida será:


```
ko = Matrix([[-1000], [-300], [-30]])
```

y el sistema bajo inyección de salida será:


```
Ako = Ao + ko*co.T
Ako
```

y su polinomio caracteristico será:


```
(s*eye(3) - Ako).det()
```

pero esta inyección de salida esta definida en la nueva base, por lo que tenemos que convertirla a la base anterior:


```
k = T*ko
k
```

Si ahora juntamosla retroalimentación de estado y la inyección de salida, tendremos:


```
Alc = (A.row_join(b*f.T)).col_join((-k*c.T).row_join(Af + k*c.T))
Alc
```


```
blc = b.col_join(b)
blc
```


```
clc = c.col_join(Matrix([[0], [0], [0]]))
clc
```

el polinomio caracteristico de este sistema será:


```
(s*eye(6) - Alc).det().factor()
```

y el polinomio de la matriz sistema:


```
MSlc = ((s*eye(6) - Alc).row_join(blc)).col_join(-clc.T.row_join(Matrix([[0]])))
MSlc
```


```
MSlc.det().factor()
```

su matriz de controlabilidad será:


```
MClc = ((((blc.row_join(Alc*blc))
          .row_join(Alc*Alc*blc))
         .row_join(Alc*Alc*Alc*blc))
        .row_join(Alc*Alc*Alc*Alc*blc)).row_join(Alc*Alc*Alc*Alc*Alc*blc)
MClc
```


```
MClc.det()
```


```
MOlc = ((((clc.T.col_join(clc.T*Alc))
          .col_join(clc.T*Alc*Alc))
         .col_join(clc.T*Alc*Alc*Alc))
        .col_join(clc.T*Alc*Alc*Alc*Alc)).col_join(clc.T*Alc*Alc*Alc*Alc*Alc)
MOlc
```


```
MOlc.det()
```


```
Tlc, Jlc = Alc.jordan_form()
```


```
Jlc
```


```
Tlc
```

5b03b41dc5f4046f09ea3d528c9c85b4c036c7d5
ipynb
Jupyter Notebook
IPythonNotebooks/Teoria de Control I/Formas canonicas observador y observabilidad.ipynb
chelizalde/DCA
34fd4d500117a9c0a75b979b8b0f121c1992b9dc
MIT
IPythonNotebooks/Teoria de Control I/Formas canonicas observador y observabilidad.ipynb
chelizalde/DCA
34fd4d500117a9c0a75b979b8b0f121c1992b9dc
MIT
IPythonNotebooks/Teoria de Control I/Formas canonicas observador y observabilidad.ipynb
chelizalde/DCA
34fd4d500117a9c0a75b979b8b0f121c1992b9dc
MIT
2021-03-20T12:44:13.000Z
2021-03-20T12:44:13.000Z
Qwen/Qwen-72B
1. YES
2. YES