Commit 23687d35 authored by c.hans's avatar c.hans
Browse files

Merge branch 'tutorial-8-1' into 'summer-2021'

Notebook zum Tutorium 8

See merge request control/teaching/grt/notebooks!9
parents 00efed1d 5fc2ea46
%% Cell type:markdown id: tags:
# Tutorium 8 Teil 1: Algebraische Regelsynthese durch Vorgabe von $T(s)$
%% Cell type:code id: tags:
``` python
import numpy as np
import matplotlib.pyplot as plt
import control as ct
import control.matlab as cm
%config InlineBackend.figure_format = 'svg'
%matplotlib notebook
```
%% Cell type:markdown id: tags:
## Beispiel Regelkreis
Gegeben sei die Strecke $G(s) = \cfrac{7,5}{s-3}$. Für diese Strecke soll ein Regler durch Vorgabe der komplementären Sensitivitätsfunktion gefunden werden.
<img src="figures/regelkreis_tutorial8_teil1.png" width=480>
Die folgenden komplementären Sensitivitätsfunktionen erfüllen die gewünschte Eigenschaften.
$$T_1(s) = \cfrac{8s+24,5}{s^2+5s+6,5}$$
$$T_2(s) = \cfrac{15s-7,5}{s^2+20s-13,5}$$
%% Cell type:code id: tags:
``` python
G = ct.tf(7.5, [1,-3])
print('Strecke G(s): \n{}'.format(G))
```
%% Output
Strecke G(s):
7.5
-----
s - 3
%% Cell type:markdown id: tags:
### Überprüfen der Implementierbarkeitsbedingungen
$T(s)\not\equiv 1$ heißt *implementierbare* komplementäre Sensitivitätsfunktion für $G(s)$, wenn eine Regler-Übertragungsfunktion $K(s)$ existiert, so dass gilt
- [ ] $T(s)$ ist realisierbar: Grad$(q_T)\geq$ Grad$(p_T)$
- [ ] $K(s)$ ist realisierbar: $\lim_{s\rightarrow\infty} T(s) \neq 1$ und (Grad$(q_T)$ - Grad$(p_T)$) $\geq$ (Grad$(q_G)$ - Grad$(p_G)$)
- [ ] Regelkreis mit $(G,K)$ ist asymptotisch stabil
Wenn diese Bedingungen erfüllt sind, kann der Regler $K(s)$ berechnet werden:
$$\begin{aligned}
T(s) &= \cfrac{G(s)K(s)}{1+G(s)K(s)} \\
\iff T(s)+T(s)G(s)K(s) &= G(s)K(s) \\
\iff K(s)(G(s)-T(s)G(s)) &= T(s) \\
\iff K(s) &= \cfrac{T(s)}{G(s)(1-T(s))}
\end{aligned}$$
%% Cell type:code id: tags:
``` python
T1 = ct.tf([8, 24.5],[1, 5, 6.5])
T2 = ct.tf([75,37.5],[1, 70, 43.5])
print('T1(s) = \n{}'.format(T1))
print('T2(s) = \n{}'.format(T2))
```
%% Output
T1(s) =
8 s + 24.5
---------------
s^2 + 5 s + 6.5
T2(s) =
75 s + 37.5
-----------------
s^2 + 70 s + 43.5
%% Cell type:code id: tags:
``` python
def check_implementable(G, T):
print('Check Implementierbarkeit von T(s)...')
# 1. Bedingung: Realisierbarkeit von T
deg_pT = len(T.num[0][0])-1 # Grad von Zählerpolynom p(s) von T(s)
deg_qT = len(T.den[0][0])-1 # Grad von Polpolynom q(s) von T(s)
print('Grad(p_T(s)) = {}, Grad(q_T(s))= {}'.format(deg_pT, deg_qT))
if deg_pT>deg_qT: # Falls Grad p(s)> Grad q(s), T(s) nicht realisierbar
print('Warnung: T(s) ist nicht realisierbar')
K =[]
# 2. Bedingung: Realisierbarkeit von K
deg_pG = len(G.num[0][0])-1 # Grad von Zählerpolynom p(s) von G(s)
deg_qG = len(G.den[0][0])-1 # Grad von Zählerpolynom p(s) von G(s)
rdeg_T = deg_qT-deg_pT # Relativgrad von T(s)
rdeg_G = deg_qG-deg_pG # Relativgrad von G(s)
print('r(T) = {}, r(G) = {} \n'.format(rdeg_T, rdeg_G))
if (rdeg_T<rdeg_G): # Falls r(T(s))<r(G(s)), K(s) nicht realisierbar
print('Warnung: K(s) ist nicht realisierbar')
K = []
# 3. Bedingung: Asymptotische Stabilität des RKs (G,K)
if check_gk_as_stable(G,T): # Siehe nächste Funktion
K = ct.minreal(T/(1-T)/G)
return K
else:
print('Warnung: Regelkreis ist nicht asymptotisch stabil')
K = []
print('Error: T(s) ist nicht implementierbar\n')
return K
```
%% Cell type:markdown id: tags:
#### Wie kann die asymptotische Stabilität eines Regelkreises (G,K) mithilfe der Strecke $G(s)$ und der komp. Sensitivitätsfunktion $T(s)$ überprufen werden?
Damit der Regelkreis $(G,K)$ asymptotisch stabil ist, müssen folgende Bedingungen erfüllt sein.
- [ ] $T(s)$ muss asymptotisch stabil sein
- [ ] Jede m-fache Nullstelle $z_G$ von $G(s)$ mit $\mathcal{R}\{z_G\}\geq 0$ muss eine mindestens m-fache Nullstelle $z_T$ von $T(s)$ sein
- [ ] Jede n-fache Polstelle $p_G$ von $G(s)$ mit $\mathcal{R}\{p_G\}\geq 0$ muss eine mindestens n-fache Nullstelle $z_S$ von $S(s)$ sein
#### Achtung: as. stabile $T(s)$ bedeutet nicht, dass das ganze Regelkreis (G,K) auch asymptotisch stabil ist (nur das Übertragungsverhalten von $r \longrightarrow y$ und $\eta \longrightarrow y$)
%% Cell type:code id: tags:
``` python
def check_gk_as_stable(G,T): # Kontrolliert die Stabilität des RKs
print('Check Asymptotische Stabilität des Regelkreis...')
# 1. Bedingung: T muss as. stabil sein
pol_T = np.round(np.roots(T.den[0][0]),5) # Pole von T berechnen
if np.any(np.real(pol_T)>=0): # Falls Re(pol)>= 0, T ist nicht as. stabil
print('Warnung: T(s) ist nicht asymptotisch stabil')
return False
# 2. Bedingung: positive reelle Nullstellen von G sind auch in T zu finden
ns_G = np.round(np.roots(G.num[0][0]),5) # Berechnen Nullstellen von G(s)
print('NS von G(s) = {}'.format(ns_G))
ns_T = np.round(np.roots(T.num[0][0]),5) # Berechnen Nullstellen von T(s)
print('NS von T(s) = {}\n'.format(ns_T))
for i in range(0, len(ns_G)):
if(np.real(ns_G[i])>=0):
if(np.real(ns_G[i]) >=0 and ns_G[i] in ns_T):
[[ind]] = np.where(ns_T==ns_G[i]) # Check, ob alle Re(NS)>=0 von G(s) auch zu NS von T(s) gehören
ns_T[ind[0]] = -1 # bereits kontrollierte Nullstelle entfernen
else:
print('Warnung: positive reelle Nullstellen von G(s) sind keine Nullstellen von T(s)')
return False
# 3. Bedingung: instabile Pole von G sind Nullstellen von S
S = 1-T; # Berechnen S(s)
pol_G = np.round(np.roots(G.den[0][0]),5) # Berechnen Polstellen von G(s)
print('Pole von G(s) = {}'.format(pol_G))
ns_S = np.round(np.roots(S.num[0][0]),5) # Berechnen Nullstellen von S(s)
print('NS von S(s) = {}\n'.format(ns_S))
for i in range(0, len(pol_G)):
if(np.real(pol_G[i])>=0):
if(np.real(pol_G[i])>=0 and pol_G[i] in ns_S): # Check, ob alle Re(PS)>=0 von G(s) auch zu NS von G(s) gehören
[ind] = np.where(ns_S==pol_G[i])
ns_S[ind[0]] = -1 # bereits kontrollierte Nullstelle entfernen
else:
print('Warnung: instabile Pole von G(s) sind keine Nullstellen von S(s)')
return False
return True
```
%% Cell type:code id: tags:
``` python
K_1 = check_implementable(G,T1)
print('K_1(s) = \n{}'.format(K_1))
```
%% Output
Check Implementierbarkeit von T(s)...
Grad(p_T(s)) = 1, Grad(q_T(s))= 2
r(T) = 1, r(G) = 1
Check Asymptotische Stabilität des Regelkreis...
NS von G(s) = []
NS von T(s) = [-3.0625]
Pole von G(s) = [3.]
NS von S(s) = [ 6. -3.]
Warnung: instabile Pole von G(s) sind keine Nullstellen von S(s)
Warnung: Regelkreis ist nicht asymptotisch stabil
Error: T(s) ist nicht implementierbar
K_1(s) =
[]
%% Cell type:code id: tags:
``` python
K_2 = check_implementable(G,T2)
print('K_2(s) = \n{}'.format(K_2))
```
%% Output
Check Implementierbarkeit von T(s)...
Grad(p_T(s)) = 1, Grad(q_T(s))= 2
r(T) = 1, r(G) = 1
Check Asymptotische Stabilität des Regelkreis...
NS von G(s) = []
NS von T(s) = [-0.5]
Pole von G(s) = [3.]
NS von S(s) = [3. 2.]
3 states have been removed from the model
K_2(s) =
10 s + 5
--------
s - 2
%% Cell type:code id: tags:
``` python
```
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment