Wolfram Regelkreise | Zum Ausprobieren

Nehmen Sie Änderungen vor und führen Sie jeden Code aus, indem Sie in den Code klicken und die Tastenkombination
+
drücken.
Modellieren, entwerfen, bereitstellen. Modellieren Sie Ihre Umgebung. Entwerfen Sie einen Regler. Stellen Sie Ihre Entwürfe zur Anwendung bereit. Alles in einem eng integrierten Workflow, der sowohl Lernenden als auch Profis entgegen kommt.

Modelle spezifizieren und umwandeln

Definieren Sie ein nichtlineares Zustandsraummodell aus nichtlinearen Differentialgleichungen:
Ausführen
In[]:=
nonlinearEqns={
′
x
1
[t]-u[t]+3
x
2
[t]-(2
x
1
[t])
x
2
[t],
′
x
2
[t]3
x
1
[t]-
x
2
[t]};​​nonlinearModel=NonlinearStateSpaceModel[nonlinearEqns,{
x
1
[t],
x
2
[t]},{u[t]},{
x
1
[t]},t]
Linearisieren Sie das Modell:
Ausführen
In[]:=
linearModel=StateSpaceModel[nonlinearModel]
Spezifieren Sie das Zustandsraummodell direkt aus Zustandsraummatrizen:
Ausführen
In[]:=
StateSpaceModel
0
3
3
-1
,
-1
0
,(
1
0
)
Wandeln Sie es in ein Übertragungsfunktionsmodell um:
Ausführen
In[]:=
TransferFunctionModel[linearModel,s]
Diskretisieren Sie ein zeitkontinuierliches Modell:
Ausführen
In[]:=
ToDiscreteTimeModel[linearModel,0.5,Method->"ZeroOrderHold"]

Entwerfen Sie einen Proportional-Integral-Differential-Regler (PID-Regler)

Definieren Sie ein Übertragungsfunktionsmodell:
Ausführen
In[]:=
dcMotor=TransferFunctionModel[{{{.01}},.0001+(.1+.01s)(1+.5s)},s]
Erstellen Sie ein Nyquist-Diagramm für das System:
Ausführen
In[]:=
NyquistPlot[dcMotor]
Berechnen Sie einen PID-Regler für das Modell:
Ausführen
In[]:=
pid=PIDTune[dcMotor,"PID","Data"]
Berechnen Sie die Reaktion auf eine Sprungeingabe:
Ausführen
In[]:=
motorResponse=OutputResponse[pid["ReferenceOutput"],UnitStep[t],{t,0,5}]
Plotten Sie die Reaktion:
Ausführen
In[]:=
Plot[motorResponse,{t,0,5},PlotRange->All]

Systeme modellieren mit Zeitverzögerung

Definieren Sie ein System mit einer Zeitverzögerung:
Ausühren
In[]:=
delayEqn=mx''[t]+cx'[t]+kx[t]-α(f[t]+x[t]-x[t-τ])/.τ->
2π
ω
Erstellen Sie ein symbolisches Zustandsraummodell:
Ausführen
In[]:=
latheModel=StateSpaceModel[delayEqn,{x[t],x'[t]},f[t],x[t],t,SystemsModelLabels{"f","x",{"x","x'"}}]
Definieren Sie numerische Parameter und ein numerisches Modell:
Ausühren
In[]:=
latheParams={m0.75,ω3,α->10,k0.1,c5,τ3};​​numericModel=latheModel/.latheParams
Erstellen Sie ein Näherungsmodell ohne Verzögerung:
Ausführen
In[]:=
approximateModel=SystemsModelDelayApproximate[numericModel,0]
Visualisieren Sie den Frequenzgang der Systeme:
Ausführen
In[]:=
BodePlot[{numericModel,approximateModel},PlotLegends->{"Delay","Delay-Free"}]
Vergleichen Sie die Ausgangsantwort der beiden Modelle auf denselben Eingang:
Ausführen
In[]:=
responses=Table[OutputResponse[system,UnitStep[t],{t,0,30}],{system,{numericModel,approximateModel}}];​​Plot[responses,{t,0,30},PlotRangeAll,PlotLegends{"Delay","Delay-Free"}]

Eine Reglersteuerung entwerfen

Definieren Sie ein affines Zustandsraummodell und den gewünschten Gleichgewichtspunkt
x
0
:
Ausführen
In[]:=
eqns=m
′′
x
[t]gm-
k
2
i[t]
2
x[t]
,v[t]ri[t]+l
′
i
[t];​​pars={r->10,m->0.05,k->1,l->0.05,g->9.8,
x
0
->0.5};​​
i
0
=
x
0
mg
k
,
v
0
=r
x
0
mg
k
/.pars;​​electromagnetModel=AffineStateSpaceModel[eqns,{{x[t],
x
0
},x'[t],{i[t],
i
0
}},{{v[t],
v
0
}},x[t],t]/.pars
In[]:=
AffineStateSpaceModel[eqns,{{x[t],
x
0
},x'[t],{i[t],
i
0
}},{{v[t],
v
0
}},x[t],t]
Definieren Sie die Rückkopplungseingabe:
Ausführen
In[]:=
feedbackModel="InputModel"->AffineStateSpaceModel[electromagnetModel,Automatic,Automatic,Automatic,None],"FeedbackInputs"->1
Berechnen Sie eine Reglersteuerung:
Ausführen
In[]:=
controllerData=LQRegulatorGains[feedbackModel,{DiagonalMatrix[{.1,.1,.1}],{{5}}},"Data"]
Ermitteln Sie das geschlossene System:
Ausführen
In[]:=
closedSystem=controllerData["ClosedLoopSystem"]//Simplify
Berechnen Sie die Zustandsantwort des geschlossenen Systems:
Ausführen
In[]:=
emResponses=StateResponse[{closedSystem,{0.8,0,0}},0,{t,0,2}]
Visualisieren Sie die Annäherung der Antwort an das gewünschte Gleichgewicht:
Ausführen
In[]:=
Plot{emResponses[[1]],
x
0
/.pars},{t,0,2},

Ermitteln Sie das Reglermodell:
Ausführen
In[]:=
emController=controllerData["ControllerModel"]
Plotten Sie die Reglerkraft:
Ausführen
In[]:=
effort=OutputResponse[emController,Join[{0},emResponses],{t,0,2}];​​Plot[effort,{t,0,2},PlotRange->All]

Einen modellprädiktiven Regler entwerfen

Berechnen Sie einen modellprädiktiven Regler aus einer vorgegebenen Kostenfunktion und Gewichten:
Ausführen
In[]:=
cost="Norm"->∞,"Horizon"3,"StateWeight"{{5,0},{0,2}},"InputWeight"{{1}};​​constraints=-2≤
x
1
≤2&&-2≤
x
2
≤2&&-1≤u≤1;​​mpc=ModelPredictiveController
0.1
0
0
1
-0.1
1
1
0
0
1
,cost,constraints
Berechnen Sie das geschlossene System:
Ausführen
In[]:=
csys=ModelPredictiveController
0.1
0
0
1
-0.1
1
1
0
0
1
,cost,constraints,"ClosedLoopSystem"
Plotten Sie die Reaktion auf eine Reihe von Anfangsbedingungen ungleich Null:
Ausführen
In[]:=
ListStepPlot[OutputResponse[{csys,<|1->{1,-1}|>},PadRight[{0,0.8},10]],PlotRange->All]

Biochemische Systeme und mehr modellieren

Laden Sie die Bio Chem-Bibliothek aus dem System Modeler Modelica Library Store. Machen Sie dann eines der folgenden Beispiele:
◼
  • Dosierungsauswahl für Arzneimittelstudien
    • ◼
  • Schätzung der Leberfunktion
    • ◼
  • Phosphorylierung von Insulinrezeptoren