[PYTHON] Einführung einer datengesteuerten Controller-Entwurfsmethode

Einführung

Die Rückkopplungssteuerung wurde verwendet, um alles von Haushaltsgeräten bis hin zu Industrieanlagen zu "steuern". Diejenigen, die diese Steuerung durchführen, werden als Steuerungen bezeichnet, und verschiedene Entwurfsmethoden wurden in Betracht gezogen. Dieses Mal möchte ich einen relativ neuen Ansatz vorstellen, der als "datengesteuerte Controller-Entwurfsmethode" bezeichnet wird.

Außerdem überlasse ich den theoretischen Teil der Arbeit und schreibe hauptsächlich über deren Verwendung. Deshalb möchte ich es mit dem Code von MATLAB und Python erklären.

Von der datengesteuerten Steuerung

Grob gesagt gibt es drei Ansätze für das Controller-Design:

1. Manuelle Parametereinstellung (Grenzempfindlichkeitsmethode usw.)
2. Modellbasiertes Reglerdesign (optimaler Regler usw.)
3. Andere ($ H_ {\ infty} $ Kontrolle, datengesteuerte Kontrolle usw.)

Da 1 manuell ist, ist es nicht schwer vorstellbar, dass das Design schwierig ist, da es Versuch und Irrtum erfordert. Daher wurde wie in 2 eine Methode vorgeschlagen, bei der das * zu steuernde mathematische Modell genau erhalten wurde * und das Modell für das Design verwendet wurde. Die Aufgabe, dieses Modell genau zu finden, heißt "Identifikation". Durch die Beschreibung des Optimierungsproblems anhand des identifizierten Modells können wir nun den theoretisch optimalen Controller erhalten. Es ist jedoch der Musiker, der dieses ** Modell genau ** will, und es erfordert viel Zeit und Mühe, Theorie und Experiment in Einklang zu bringen. Daher wurden andere Methoden in Betracht gezogen, die auf der Annahme beruhen, dass ** Modelle nicht genau erhalten werden können **. Datengesteuerte Steuerung ist eine davon.

Was ist datengesteuerte Steuerung?

Was ist laut der Website von Professor Kaneko von der Universität für Telekommunikation datengesteuerte Steuerung?

Eine Methode zum Entwerfen einer Steuerung direkt aus den Daten und dem Verhalten des Geräts, das gesteuert werden soll, wenn es angesteuert wird.

ist. Mit anderen Worten, die Steuerung kann entworfen werden, ohne ein Modell zu erstellen, solange während der Fahrt Signaldaten vorliegen.

Es gibt zwei derzeit bekannte datengesteuerte Steuerungsentwurfsmethoden [^ Entschuldigung IFT].

[^ Entschuldigung]: Historisch gesehen müssen nicht-Beweiskontrolle und IFT erklärt werden, aber ich werde sie weglassen.

Dieses Mal habe ich den Code über VRFT geschrieben, da das Optimierungsproblem leicht gelöst werden kann.

Beispiel-Code-Ausführungsumgebung

• MATLAB 2017b
  • Control System Toolbox
  • System Identification Toolbox
• Python 3.7.5 (Anaconda Umgebung)
  • matplotlib
  • numpy
  • scipy
  • python-control

Beachten Sie, dass der Python-Code in der Erklärung die Importanweisung weglässt. Siehe [Ganzer Code](#Whole Code) für Arbeitscode.

VRFT-Verfahren

Es gibt nur drei Dinge, die ein Designer tun muss, um VRFT zu verwenden.

1. Bestimmung der Entwurfsspezifikationen
2. Erfassung von Eingabe- / Ausgabedaten
3. Lösen Sie das Optimierungsproblem gemäß dem Algorithmus

Dieses Mal werde ich das Reglerdesign des Drehzahlregelungssystems am Beispiel eines Motors erläutern.

Designspezifikationen bestimmen

Lassen Sie uns zunächst die Designspezifikationen festlegen. Die folgenden drei Entwurfsspezifikationen können bestimmt werden.

Wenn Sie beispielsweise möchten, dass der PID-Regler eine Antwort mit einer Zeitkonstante von $ \ tau = 0,02 $ [s] liefert,

\begin{align}
M(s) &= \frac{1}{0.02 s + 1} \\&= \frac{50}{s + 50}\\
\boldsymbol{\beta}(s) &= \begin{bmatrix}1& \frac{1}{s}& s\end{bmatrix}^\mathrm{T}
\end{align}

Stellen Sie wie folgt ein. In Anbetracht der hohen Wahrscheinlichkeit, dass Rauschen in den Daten im Hochfrequenzbereich gemischt wird, ist es häufig ausreichend, ein Tiefpassfilter für das Frequenzgewicht einzustellen.

Der obige Code lautet wie folgt.

vrft.m

%Abtastzeit und Operatoren
Ts = 0.001;
s = tf('s');        %Laplace-Operator s
z = tf('z', Ts);    %Zeitvorschuboperator z

%Referenzmodell M.
tau = 0.02;
M = c2d(1/(tau*s + 1), Ts); %Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

%Gewichtsfunktion
gW = 100;
W = c2d(gW/(s + gW), Ts);   %Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

%Kontrollstruktur Beta
beta = minreal([1; Ts/(1 - z^-1); (1 - z^-1)/Ts]); %PID-Regler

vrft.py

# ===Designspezifikationen bestimmen===
#Abtastzeit
Ts = 0.001

#Referenzmodell M.
tau = 0.02
M = ctl.c2d(ctl.tf([1], [tau, 1]), Ts)  #Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

#Gewichtsfunktion W.
gW = 100
W = ctl.c2d(ctl.tf([gW], [1, gW]), Ts)  #Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

#Kontrollstruktur Beta
A, B, C, D = abcd_normalize(
    [[1., 0], [0, 0]],
    [[1.], [-1.]],
    [[0, 0], [Ts, 0], [0, -1/Ts]],
    [[1.], [0], [1/Ts]])
beta = ctl.ss(A, B, C, D, Ts)
del A, B, C, D

Erfassung von Eingabe- / Ausgabedaten

Als nächstes werden die Eingabe- / Ausgabedaten $ \ {u_0 (t), y_0 (t) } $ vom Steuerungsziel erfasst. Im Fall von VRFT werden Daten erfasst, so dass die folgenden Bedingungen erfüllt sind.

• Achten Sie darauf, die Antwort der offenen Schleife zu erhalten (nur $ P (s) $ ohne Kontrolle)
• Verwenden Sie nach Möglichkeit das weiße Eingangssignal $ u_0 (t) $

Als Weißsignal wird empfohlen, das Signal der M-Serie zu verwenden, das häufig zur Systemidentifizierung verwendet wird. Im Fall von MATLAB können Signale der M-Serie einfach mit der idinput-Funktion der System Identification Toolbox generiert werden. Im Fall von Python kann es von Scipys [max_len_seq-Funktion] generiert werden (https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.max_len_seq.html?highlight=correlation). Es scheint jedoch, dass Signale einer anderen Serie als MATLAB generiert werden. In dieser Python-Version habe ich meine eigene Funktion prbs () erstellt und verwendet.

Hier wird ein Modell des gesteuerten Objekts (in diesem Fall Motor) benötigt, um die Simulation durchzuführen [^ note1]. Also dachte ich ursprünglich, dass es notwendig ist, das Modell des Motors zu erklären, aber Manaos Großartiger Artikel Ich habe Artikel gefunden / ed383a30bbe0c7b9534a). Daher entfällt hier die Modellierung, und der Motor kann durch ein Primärsystem dargestellt werden.

[^ note1]: Beachten Sie, dass dies nur zum Abrufen von Daten benötigt wird und kein Modell im Entwurf verwendet wird. (Tatsächlich kann es nach der Datenerfassung als "Clearvars P" entworfen werden.)

Daher können in der Simulation Daten mit dem folgenden Code erfasst werden.

vrft.m

%Eingangssignal zur Datenerfassung u(m Serien-Signal)
n = 15;                                     %Anzahl der Stufen
T = 2^n - 1;                                %Anzahl der Daten pro Zyklus
p = 15;                                     %Anzahl der Datenzyklen
N = T*p;                                    %Die Anzahl der Daten
u0 = idinput([T 1 p],'prbs',[0,1],[-1,1]);   %Signalvektor

%Leistungsspektrumsdichte des Eingangssignals phi_u
phi_u = 1;                  %Das Eingangssignal wird als weiß angenommen

%Kontrolliertes Modell P.
Tp = 0.74;
Kp = 1.02;
P = c2d(Kp/(Tp*s + 1), Ts);

%Ausgangssignal y0
y0 = lsim(P, u0);

vrft.py

# ===Erfassung von Eingabe- / Ausgabedaten===
def prbs(n, p):
    # matlab compatible PRBS signal generator

    taps = {3: [0, -1], 4: [0, -1], 5: [1, -1], 6: [0, -1], 7: [0, -1],
            8: [0, 1, 6, -1], 9: [3, -1], 10: [2, -1], 11: [8, -1],
            12: [5, 7, 10, -1], 13: [8, 9, 11, -1], 14: [3, 7, 12, -1],
            15: [13, -1], 16: [3, 12, 14, -1], 17: [13, -1], 18: [10, -1]}
    N = (2**n - 1)*p
    x = np.ones(n, dtype=np.int8)
    u = np.zeros(N, dtype=np.int8)
    tap = taps[n]
    for i in range(N):
        u[i] = x[-1]
        x0 = x[tap[0]] ^ x[tap[1]]
        x = np.roll(x, 1)
        x[0] = x0
    return u


#Eingangssignal zur Datenerfassung u(m Serien-Signal)
n = 15
T = 2**n - 1
p = 15
N = T*p
# u0, _ = max_len_seq(n, length=N)  #Die Signalreihe unterscheidet sich von der von MATLAB
u0 = prbs(n, p)
u0 = -(2.*u0 - 1.)

#Leistungsspektrumsdichte des Eingangssignals phi_u
phi_u = 1.

#Kontrolliertes Modell P.
Tp = 0.74
Kp = 1.02
P = ctl.c2d(ctl.tf([Kp], [Tp, 1]), Ts)

#Ausgangssignal y0
y0, t0, _ = ctl.lsim(P, u0)

Lösen Sie die Optimierungsberechnung gemäß dem Algorithmus

Schließlich wird das Signal gemäß dem VRFT-Algorithmus erzeugt und die Optimierungsberechnung gelöst.

Dies ist ein Minimierungsproblem für die Bewertungsfunktion $ J_ \ mathrm {MR} (\ boldsymbol {\ rho}) $, da VRFT darauf abzielt, so nah wie möglich am Referenzmodell $ M (z) $ zu reagieren.

\begin{align}
J_\mathrm{MR}(\boldsymbol{\rho}) &= \left\| \left( \frac{P(z) C(z, \boldsymbol{\rho})}{1 + P(z) C(z, \boldsymbol{\rho})} - M(z) \right) W(z) \right\|_2 ^2
\end{align}

Hier repräsentiert $ \ boldsymbol {\ rho} $ den Steuerparameter und $ C (z, \ boldsymbol {\ rho}) = \ boldsymbol {\ rho} ^ {\ rm T} \ boldsymbol {\ beta } (z) Es besteht eine $ -Beziehung. Da diese Formel jedoch das kontrollierte Modell $ P (z) $ verwendet, muss es mit Eingabe- / Ausgabedaten neu geschrieben werden. Die theoretische Erklärung ist abgeschnitten, aber das Problem der Minimierung der Bewertungsfunktion $ J_ \ mathrm {MR} $ ist das folgende, und das Problem der Minimierung von $ J_ \ mathrm {VR} ^ N $ ist allmählich. Ist äquivalent zu.

\begin{align}
J_{\rm VR}^{N}(\boldsymbol{\rho}) &= \frac{1}{N} \sum_{t=1}^{N}(u_L(k) - \boldsymbol{\rho}^{\rm T} \boldsymbol{\varphi}(t))^2
\end{align}

Hier können die Zeitreihendaten $ u_L (t) $ und $ \ boldsymbol {\ rho} $ durch die folgende Formel unter Verwendung des Filters $ L (z) $ erzeugt werden.

\begin{align}
u_L(t) &= L(z) u_0(t)\\
y_L(t) &= L(z) y_0(t)\\
%\boldsymbol{\varphi}(k) &= \boldsymbol{\beta}(z) (\tilde{r}_L(t) - y_L(t))
e_L(t) &= (M^{-1} - 1)y_L(t)\\
\boldsymbol{\varphi}(k) &= \boldsymbol{\beta}(z) e_L(t)
\end{align}

Der Filter $ L (z) $ muss jedoch Folgendes erfüllen.

\begin{align}
|L(z)|^2 &= \frac{|1-M(z)|^2 |M(z)|^2 |W(z)|^2}{\phi_u(\omega)} &\forall \omega
\end{align}

Dann verwendet $ J_ \ mathrm {VR} ^ N (\ boldsymbol {\ rho}) $ nicht das kontrollierte Modell $ P (z) $ und die Eingabe- / Ausgabedaten $ \ {u_0 (t), y_0 (t) Es kann nur mit) } $ beschrieben werden. Da diese Gleichung in Bezug auf den Steuerparameter $ \ boldsymbol {\ rho} $ linear ist, kann sie auch durch die Methode der kleinsten Quadrate gelöst werden.

Der obige Teil, der das Optimierungsproblem löst, ist der folgende Code.

vrft.m

%Vorfilter L.
L = minreal(M*(1 - M)/phi_u);

%Gefiltertes Eingangssignal ul
ul = lsim(L, u0);

%Pseudofehlersignal el
el = lsim(L*(M^(-1) - 1), y0);

%Steuerausgang vor Parametern phi
phi = lsim(beta, el);

%Optimaler Parameter rho
rho = phi\ul;               %Lösen Sie die Methode der kleinsten Quadrate in Matrixform(mldivide)

%Entwickelte Steuerung C.
C = minreal(rho.' * beta);  %Fragen Sie nach einem Controller

%Bewertungsfunktion Jmr
Jmr = mean(ul - phi * rho); %Überprüfen Sie die Auswertungsfunktion im Matrixformat

vrft.py

# ===Entworfen von VRFT===
#Vorfilter L.
L = ctl.minreal(M*(1 - M)/phi_u)

#Gefiltertes Eingangssignal ul
ul, _, _ = ctl.lsim(L, u0)

#Pseudofehlersignal el
el, _, _ = ctl.lsim(ctl.minreal(L*(M**-1 - 1)), y0.flatten())

#Steuerung der Ausgabe vor den Parametern
phi, _, _ = ctl.lsim(beta, el.flatten())

#Optimaler Parameter rho
solution = np.linalg.lstsq(phi, ul, rcond=None)
rho = solution[0]

#Entwickelte Steuerung C.
C = ctl.ss([0], [0, 0, 0], [0], rho.T, Ts) * beta   #Fragen Sie nach einem Controller

#Bewertungsfunktion Jmr
Jmr = np.mean(ul - np.dot(phi, rho))    #Überprüfen Sie die Auswertungsfunktion im Matrixformat

Leistungsbestätigung

Mit dem obigen Verfahren scheint es, dass die Steuerung nur unter Verwendung der Eingabe- / Ausgabedaten entworfen werden könnte, ohne das zu steuernde Modell zu verwenden. Die optimalen Steuerparameter $ \ rho $, die erhalten werden, sind wie folgt. Sie können sehen, dass MATLAB und Python fast die gleichen Ergebnisse liefern.

[^ ideal]: $ M (z) = \ frac {C ^ * (z) P (z)} {1 + C ^ * (z) P (z)} Ein Controller, der $ C ^ * $ erfüllt Wert (dies wird als idealer Controller bezeichnet)

Lassen Sie uns nun überprüfen, ob die Antwort des Referenzmodells von diesem Steuerelement wirklich realisiert wird. Der zu überprüfende Code lautet wie folgt.

vrft.m

%Gesamtsystem mit Controller G.
G = minreal(feedback(P*C, 1));

%Sprungantwort
fig1 = figure('name', 'Step plot');
stepplot(G, M);
legend({'$$\frac{CP}{1+CP}$$', '$M$'},...
    'Interpreter', 'latex', 'FontSize', 14, 'Location', 'southeast');

%Platinendiagrammanzeige
fig2 = figure('name', 'Bode plot of controller');
bodeplot(G, M, {1,100});

vrft.py

# ===Leistungsbestätigung===
#Gesamtsystem mit Controller G.
G = ctl.minreal(ctl.feedback(P*C, 1))

#Sprungantwort
plt.figure()
plt.title("Step response of closed loop system")
timeRange = np.arange(0, 0.12 + Ts, Ts)
ym, _ = ctl.step(M, timeRange)
yg, _ = ctl.step(G, timeRange)
plt.plot(timeRange, ym, timeRange, yg)
plt.xlabel("Time [s]", usetex=True)
plt.ylabel("Velocity [V]")
plt.legend(['Reference model', 'Closed loop system'], loc='lower right')

#Platinendiagrammanzeige
plt.figure()
plt.title("Bode plot of closed loop system")
ctl.bode(M, G)
plt.legend(['Reference model', 'Closed loop system'], loc='lower left')
plt.show()

Hier wird nur die Sprungantwort als Bild angezeigt. Sie können sehen, dass die Antwort des Referenzmodells mit nicht unterscheidbarer Genauigkeit reproduziert werden kann.

Ganzer Code

Abschließend zeige ich Ihnen den gesamten Code, den ich eingeführt habe.

%VRFT-Design-Skript
%Design für das Drehzahlregelsystem des Motors.

% Copyright (c) 2019 larking95(https://qiita.com/larking95)
% Released under the MIT Licence 
% https://opensource.org/licenses/mit-license.php

%%Initialisieren
clearvars;
close all;

%%Designspezifikationen bestimmen
%Abtastzeit und Operatoren
Ts = 0.001;
s = tf('s');        %Laplace-Operator s
z = tf('z', Ts);    %Zeitvorschuboperator z

%Referenzmodell M.
tau = 0.02;
M = c2d(1/(tau*s + 1), Ts); %Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

%Gewichtsfunktion
gW = 100;
W = c2d(gW/(s + gW), Ts);   %Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

%Kontrollstruktur Beta
beta = minreal([1; Ts/(1 - z^-1); (1 - z^-1)/Ts]); %PID-Regler

%%Erfassung von Eingabe- / Ausgabedaten
%Eingangssignal zur Datenerfassung u(m Serien-Signal)
n = 15;                                     %Anzahl der Stufen
T = 2^n - 1;                                %Anzahl der Daten pro Zyklus
p = 15;                                     %Anzahl der Datenzyklen
N = T*p;                                    %Die Anzahl der Daten
u0 = idinput([T 1 p],'prbs',[0,1],[-1,1]);   %Signalvektor

%Leistungsspektrumsdichte des Eingangssignals phi_u
phi_u = 1;                  %Das Eingangssignal wird als weiß angenommen

%Kontrolliertes Modell P.
Tp = 0.74;
Kp = 1.02;
P = c2d(Kp/(Tp*s + 1), Ts);

%Ausgangssignal y0
y0 = lsim(P, u0);

%%Entworfen von VRFT
%Vorfilter L.
L = minreal(M*(1 - M)/phi_u);

%Gefiltertes Eingangssignal ul
ul = lsim(L, u0);

%Pseudofehlersignal el= 
el = lsim(L*(M^(-1) - 1), y0);

%Steuerausgang vor Parametern phi
phi = lsim(beta, el);

%Optimaler Parameter rho
rho = phi\ul;               %Lösen Sie die Methode der kleinsten Quadrate in Matrixform(mldivide)

%Entwickelte Steuerung C.
C = minreal(rho.' * beta);  %Fragen Sie nach einem Controller

%Bewertungsfunktion Jmr
Jmr = mean(ul - phi * rho); %Überprüfen Sie die Auswertungsfunktion im Matrixformat

%%Leistungsbestätigung
%Gesamtsystem mit Controller G.
G = minreal(feedback(P*C, 1));

%Sprungantwort
fig1 = figure('name', 'Step plot');
stepplot(G, M);

%Platinendiagrammanzeige
fig2 = figure('name', 'Bode plot of controller');
bodeplot(G, M, {1,100});

# -*- coding: utf-8 -*-
"""
VRFT-Design-Skript
Design für das Drehzahlregelsystem des Motors.

Copyright (c) 2019 larking95(https://qiita.com/larking95)
Released under the MIT Licence 
https://opensource.org/licenses/mit-license.php
"""

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

# from scipy.signal import max_len_seq
from scipy.signal import abcd_normalize


def prbs(n, p):
    # matlab compatible PRBS signal generator

    taps = {3: [0, -1], 4: [0, -1], 5: [1, -1], 6: [0, -1], 7: [0, -1],
            8: [0, 1, 6, -1], 9: [3, -1], 10: [2, -1], 11: [8, -1],
            12: [5, 7, 10, -1], 13: [8, 9, 11, -1], 14: [3, 7, 12, -1],
            15: [13, -1], 16: [3, 12, 14, -1], 17: [13, -1], 18: [10, -1]}
    N = (2**n - 1)*p
    x = np.ones(n, dtype=np.int8)
    u = np.zeros(N, dtype=np.int8)
    tap = taps[n]
    for i in range(N):
        u[i] = x[-1]
        x0 = x[tap[0]] ^ x[tap[1]]
        x = np.roll(x, 1)
        x[0] = x0
    return u


# ===Designspezifikationen bestimmen===
#Abtastzeit
Ts = 0.001

#Referenzmodell M.
tau = 0.02
M = ctl.c2d(ctl.tf([1], [tau, 1]), Ts)  #Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

#Gewichtsfunktion W.
gW = 100
W = ctl.c2d(ctl.tf([gW], [1, gW]), Ts)  #Verzögerungssystem erster Ordnung, diskretisiert durch Halten nullter Ordnung

#Kontrollstruktur Beta
A, B, C, D = abcd_normalize(
    [[1., 0], [0, 0]],
    [[1.], [-1.]],
    [[0, 0], [Ts, 0], [0, -1/Ts]],
    [[1.], [0], [1/Ts]])
beta = ctl.ss(A, B, C, D, Ts)
del A, B, C, D

# ===Erfassung von Eingabe- / Ausgabedaten===
#Eingangssignal zur Datenerfassung u(m Serien-Signal)
n = 15
T = 2**n - 1
p = 15
N = T*p
# u0, _ = max_len_seq(n, length=N)  #Die Signalreihe unterscheidet sich von der von MATLAB
u0 = prbs(n, p)
u0 = -(2.*u0 - 1.)

#Leistungsspektrumsdichte des Eingangssignals phi_u
phi_u = 1.

#Kontrolliertes Modell P.
Tp = 0.74
Kp = 1.02
P = ctl.c2d(ctl.tf([Kp], [Tp, 1]), Ts)

#Ausgangssignal y0
y0, t0, _ = ctl.lsim(P, u0)

# ===Entworfen von VRFT===
#Vorfilter L.
L = ctl.minreal(M*(1 - M)/phi_u)

#Gefiltertes Eingangssignal ul
ul, _, _ = ctl.lsim(L, u0)

#Pseudofehlersignal el
el, _, _ = ctl.lsim(ctl.minreal(L*(M**-1 - 1)), y0.flatten())

#Steuerung der Ausgabe vor den Parametern
phi, _, _ = ctl.lsim(beta, el.flatten())

#Optimaler Parameter rho
solution = np.linalg.lstsq(phi, ul, rcond=None)
rho = solution[0]

#Entwickelte Steuerung C.
C = ctl.ss([0], [0, 0, 0], [0], rho.T, Ts) * beta   #Fragen Sie nach einem Controller

#Bewertungsfunktion Jmr
Jmr = np.mean(ul - np.dot(phi, rho))    #Überprüfen Sie die Auswertungsfunktion im Matrixformat

# ===Leistungsbestätigung===
#Gesamtsystem mit Controller G.
G = ctl.minreal(ctl.feedback(P*C, 1))

#Sprungantwort
plt.figure()
plt.title("Step response of closed loop system")
timeRange = np.arange(0, 0.12 + Ts, Ts)
ym, _ = ctl.step(M, timeRange)
yg, _ = ctl.step(G, timeRange)
plt.plot(timeRange, ym, timeRange, yg)
plt.xlabel("Time [s]", usetex=True)
plt.ylabel("Velocity [V]")
plt.legend(['Reference model', 'Closed loop system'], loc='lower right')

#Platinendiagrammanzeige
plt.figure()
plt.title("Bode plot of closed loop system")
ctl.bode(M, G)
plt.legend(['Reference model', 'Closed loop system'], loc='lower left')
plt.show()

abschließend

Dieses Mal habe ich, während ich die Theorie komplett weggelassen habe, den Umriss des datengesteuerten Controller-Designs und den tatsächlichen Code für einen von ihnen, VRFT, eingeführt. Steuerungstechnik Ich weiß nicht so viel wie die anderen Teilnehmer des Adventskalenders, aber ich hoffe, es hilft allen, sich für datengesteuerte Steuerung zu interessieren.

Wenn Sie Bedenken haben, können Sie diese gerne kommentieren.

Verweise

1. Einführung von VRFT (Website von Campi und Savaresi)
2. Einführung von FRIT (Einführungsartikel von Professor Kaneko)
3. [Grundlagen der Systemidentifikation](https://www.amazon.co.jp/%E3%82%B7%E3%82%B9%E3%83%86%E3%83%A0%E5%90% 8C% E5% AE% 9A% E3% 81% AE% E5% 9F% BA% E7% A4% 8E-% E8% B6% B3% E7% AB% 8B-% E4% BF% AE% E4% B8% 80 / dp / 4501114800) (Buch von Dr. Adachi)
4. Systemidentifikation des Gleichstrommotors mit Arduino und MATLAB / Simulink (Manao Artikel )
5. NumPy for Matlab users(Scipy.org)