Übertragungsfunktion / Zustandsraummodell des Feder- / Masse- / Dämpfersystems und Simulation von Python

Überblick

Studiennotizen zur Steuerungstechnik. Das Übertragungsfunktions- / Zustandsraummodell wird aus der Bewegungsgleichung des Qualitätspunktes des Feder-Masse-Dämpfer-Systems und der Python-Bibliothek des Steuerungssystems "Python Control Systems Library erhalten. 0.8.3 / index.html) ”wird für die Simulation verwendet.

• Verwandter Eintrag: RLC-Serienschaltungsübertragungsfunktion / Zustandsraummodell und Simulation von Python

Bewegungsgleichung des Qualitätspunktes mit einem Freiheitsgrad im Feder-Masse-Dämpfer-System

$ \ ddot {y} (t) $ ist Beschleunigung, $ \ dot {y} (t) $ ist Geschwindigkeit und $ y (t) $ ist Verschiebung. $ m $ ist die Masse, $ c $ ist der Dämpfungskoeffizient und $ k $ ist die Federkonstante (beide sind physikalische Konstanten und daher nicht negative Werte).

Modellieren Sie das System mit einer Übertragungsfunktion

Laplace-Konvertierung der Kraft $ f (t) $ als ** Eingabe ** in das System und Verschiebung $ y (t) $ als ** Ausgabe ** vom System zum System ** Übertragungsfunktion ** $ G ( Das Finden von s) = Y (s) / F (s) $ ergibt: (Zu diesem Zeitpunkt sind die Anfangswerte von Geschwindigkeit und Verschiebung Null, dh $ \ dot {y} (0) = 0 $ und $ y. (0) = 0 $).

Modellierung / Simulation mit Python

Verwenden Sie zur Simulation die ** Python Control Systems Library ** von Python. Stellen Sie die Übertragungsfunktion ein, um das System zu modellieren und die ** Impulsantwort ** zu simulieren.

Vorbereitung (Google Colab.Umgebung)

!pip install --upgrade sympy
!pip install slycot
!pip install control

Impulsantwortsimulation (Übertragungsfunktion)

import numpy as np
import control.matlab as ctrl
import matplotlib.pyplot as plt

m = 1    #Masse[kg]Nicht negativ
c = 1    #Dämpfungskoeffizient[N/m]Nicht negativ
k = 10   #Federkoeffizient[Ns/m]Nicht negativ

sys = ctrl.tf((1),(m,c,k)) #Übertragungsfunktion
print(sys)

t_range = (0,10) #Simulieren Sie den Bereich von 0 bis 10 Sekunden
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()

Ausführungsergebnis

           1
-----------------------
1e-08 s^2 + 2e-05 s + 1

Modelliert mit einem Zustandsraummodell

Im Zustandsraummodell können mehrere Beobachtungsgrößen (Ausgänge) eingestellt werden. Zusätzlich ist es möglich, mit jedem Anfangswert zu berechnen.

Modellieren Sie das System in das folgende Zustandsraummodell $ \ mathcal {P} $.

python

\mathcal{P}\,:\,\left\{
\begin{array}{l}
\dot{\boldsymbol{x}} = \mathbf{A}\boldsymbol{x} + \mathbf{B}\boldsymbol{u}&Zustandsgleichung\\
\boldsymbol{y} = \mathbf{C}\boldsymbol{x} + \mathbf{D}\boldsymbol{u}&Ausgangsgleichung (Beobachtungsgleichung)
\end{array}
\right.

Transformieren Sie zur Vorbereitung die Bewegungsgleichung in $ \ ddot {y} (t) = ... $.

Als $ x \ _1 (t) = y (t) $, $ x \ _2 (t) = \ dot {y} (t) $, ** Zustand ** $ \ boldsymbol {x} = \ [x \ _1 , , x \ _2] ^ T $ ist definiert. ** Verschiebung ** $ y (t) $ ist der Zustand $ x_1 $, ** Geschwindigkeit ** $ \ dot {y} (t) $ ist der Zustand $ x_2 $. </ font>

\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

\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

y = \left[
    \begin{array}{cc}
      1 & 0 \\
      0 & 1 \\
    \end{array}
  \right]   \left[
    \begin{array}{c}
      x_1 \\
      x_2
    \end{array}
  \right]

!pip install japanize-matplotlib

import numpy as np
import control.matlab as ctrl
import matplotlib.pyplot as plt
import japanize_matplotlib

m = 1    #Masse[kg]Nicht negativ
c = 1    #Dämpfungskoeffizient[N/m]Nicht negativ
k = 10   #Federkoeffizient[Ns/m]Nicht negativ

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（=Anfangswert der Verschiebung) ist 0.Auf 1 setzen. x2 (=Anfangswert der Geschwindigkeit) wird auf 0 gesetzt
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(['Verschiebung','Geschwindigkeit']) :
  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()