Fonction de transmission / modèle d'espace d'état du système ressort / masse / amortisseur et simulation par Python
Aperçu
Notes d'étude d'ingénierie de contrôle. Trouvez la fonction de transfert / le modèle d'espace d'état à partir de l'équation de mouvement du point de qualité du système ressort-masse-amortisseur, et trouvez la bibliothèque Python du système de contrôle "[Python Control Systems Library](https://python-control.readthedocs.io/en/ 0.8.3 / index.html) »est utilisé pour la simulation.
- Entrée connexe: Fonction de transfert de circuit série RLC / modèle d'espace d'état et simulation par Python
Équation de mouvement d'un point de qualité à un degré de liberté dans un système ressort-masse-amortisseur
$ \ ddot {y} (t) $ est l'accélération, $ \ dot {y} (t) $ est la vitesse et $ y (t) $ est le déplacement. $ m $ est la masse, $ c $ est le coefficient d'amortissement et $ k $ est la constante de ressort (les deux sont des constantes physiques et donc des valeurs non négatives).
Modélisez le système avec une fonction de transfert
Conversion de Laplace de la force $ f (t) $ en ** entrée ** au système et du déplacement $ y (t) $ en ** sortie ** du système au système ** fonction de transfert ** $ G ( Trouver s) = Y (s) / F (s) $ donne: (À ce moment, les valeurs initiales de vitesse et de déplacement sont nulles, c'est-à-dire $ \ dot {y} (0) = 0 $ et $ y (0) = 0 $).
Modélisation / simulation avec Python
Utilisez la ** Python Control Systems Library ** de Python pour la simulation. Définissez la fonction de transfert pour modéliser le système et simuler la ** réponse impulsionnelle **.
Préparation (Google Colab.environnement)
!pip install --upgrade sympy
!pip install slycot
!pip install control
Simulation de réponse impulsionnelle (fonction de transmission)
import numpy as np
import control.matlab as ctrl
import matplotlib.pyplot as plt
m = 1 #Masse[kg]Non négatif
c = 1 #Coefficient d'atténuation[N/m]Non négatif
k = 10 #Coefficient de ressort[Ns/m]Non négatif
sys = ctrl.tf((1),(m,c,k)) #Fonction de transfert
print(sys)
t_range = (0,10) #Simuler la plage de 0 à 10 secondes
y, t = ctrl.impulse(sys, T=np.arange(*t_range, 0.01))
plt.figure(figsize=(7,4),dpi=120,facecolor='white')
plt.hlines(0,*t_range,colors='gray',ls=':')
plt.plot(t,y)
plt.xlim(*t_range)
plt.show()
Résultat d'exécution
1
-----------------------
1e-08 s^2 + 2e-05 s + 1
Modélisé avec un modèle d'espace d'état
Dans le modèle d'espace d'état, plusieurs quantités d'observation (sorties) peuvent être définies. De plus, il est possible de calculer avec n'importe quelle valeur initiale.
Modélisez le système dans le modèle d'espace d'état suivant $ \ mathcal {P} $.
python
\mathcal{P}\,:\,\left\{
\begin{array}{l}
\dot{\boldsymbol{x}} = \mathbf{A}\boldsymbol{x} + \mathbf{B}\boldsymbol{u}&Équation d'état\\
\boldsymbol{y} = \mathbf{C}\boldsymbol{x} + \mathbf{D}\boldsymbol{u}&Équation de sortie (équation d'observation)
\end{array}
\right.
En guise de préparation, transformez l'équation de mouvement en $ \ ddot {y} (t) = ... $.
Comme $ x \ _1 (t) = y (t) $, $ x \ _2 (t) = \ dot {y} (t) $, ** état ** $ \ boldsymbol {x} = \ [x \ _1 , , x \ _2] ^ T $ est défini. ** Déplacement ** $ y (t) $ est l'état $ x_1 $, ** Vitesse ** $ \ dot {y} (t) $ est l'état $ x_2 $. </ font>
À partir de là, $ \ dot {x} \ _1 (t) = \ dot {y} (t) = x \ _2 $.
De plus, $ \ dot {x} \ _2 (t) = \ ddot {y} (t) = - \ frac {k} {m} y (t) - \ frac {c} {m} \ dot {y} (t) + \ frac {1} {m} f (t) $.
Si la force $ f (t) $ est l'entrée $ u (t) $, la ** équation d'état ** suivante est obtenue à partir de ce qui précède.
python
\left[
\begin{array}{c}
\dot{x}_1 \\
\dot{x}_2
\end{array}
\right]
=\left[
\begin{array}{cc}
0 & 1 \\
-\frac{k}{m} & -\frac{c}{m}
\end{array}
\right]
\left[
\begin{array}{c}
x_1 \\
x_2
\end{array}
\right]
+ \left[
\begin{array}{c}
0 \\
\frac{1}{m}
\end{array}
\right] u
python
\dot{\boldsymbol{x}}
=\left[
\begin{array}{cc}
0 & 1 \\
-\frac{k}{m} & -\frac{c}{m}
\end{array}
\right]
\boldsymbol{x} + \left[
\begin{array}{c}
0 \\
\frac{1}{m}
\end{array}
\right] u
De plus, on obtient la ** équation de sortie ** suivante (équation d'observation) (on observe l'état $ x_1 $ correspondant au ** déplacement ** et l'état $ x_2 $ correspondant à la ** vitesse **).
python
y = \left[
\begin{array}{cc}
1 & 0 \\
0 & 1 \\
\end{array}
\right] \left[
\begin{array}{c}
x_1 \\
x_2
\end{array}
\right]
Cependant, $ \ mathbf {D} = 0 $.
Modélisation / simulation avec Python
Simulez la ** réponse impulsionnelle ** dans le modèle d'espace d'états. Contrairement au cas de la fonction de transfert, $ 0,1 $ est défini comme valeur initiale du déplacement, et la vitesse est également sortie (observée).
Préparation à l'utilisation du japonais sur les graphiques (Google Colab.environnement)
!pip install japanize-matplotlib
Simulation de réponse impulsionnelle (modèle d'espace d'états avec valeurs initiales)
import numpy as np
import control.matlab as ctrl
import matplotlib.pyplot as plt
import japanize_matplotlib
m = 1 #Masse[kg]Non négatif
c = 1 #Coefficient d'atténuation[N/m]Non négatif
k = 10 #Coefficient de ressort[Ns/m]Non négatif
A = [[0,1],[-k/m, -c/m]]
B = [[0],[1/m]]
C = [[1,0],[0,1]]
D = 0
sys = ctrl.ss(A,B,C,D)
#print(sys)
t_range = (0,10)
# x1（=La valeur initiale du déplacement) est 0.Réglez sur 1. x2 (=Valeur initiale de la vitesse) est définie sur 0
y, t = ctrl.impulse(sys, T=np.arange(*t_range, 0.01), X0=[0.1, 0.0])
fig, ax = plt.subplots(nrows=2, figsize=(7,5),dpi=120,sharex='col')
fig.patch.set_facecolor('white')
fig.subplots_adjust(hspace=0.1)
for i,s in enumerate(['Déplacement','la vitesse']) :
ax[i].hlines(0,*t_range,colors='gray',ls=':')
ax[i].plot(t,y[:,i])
ax[i].set_ylabel(s)
ax[i].set_xlim(*t_range)
plt.show()
Le résultat de l'exécution est le suivant. 
Recommended Posts