Systèmes de contrôle avec Wolfram | Choses à essayer

Effectuez des modifications et exécutez n’importe quel morceau de code en cliquant à l’intérieur du code et en appuyant sur
+
.
Modélisez, concevez, déployez. Modélisez l’environnement. Concevez un contrôleur. Déployez dans le monde réel. Le tout dans un flux de travail hautement intégré, développé pour les apprenants et les professionnels.

Spécifiez et convertissez les modèles

Définissez un modèle espace-état non linéaire à partir d’équations différentielles non linéaires :
Exécuter
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]
Linéarisez le modèle :
Exécuter
In[]:=
linearModel=StateSpaceModel[nonlinearModel]
Spécifiez le modèle espace-état directement à partir des matrices espace-état :
Exécuter
In[]:=
StateSpaceModel
0
3
3
-1
,
-1
0
,(
1
0
)
Convertissez en un modèle de fonction de transfert :
Exécuter
In[]:=
TransferFunctionModel[linearModel,s]
Discrétisez un modèle à temps continu :
Exécuter
In[]:=
ToDiscreteTimeModel[linearModel,0.5,Method->"ZeroOrderHold"]

Concevez un régulateur proportionnel-intégral-différentiel (PID)

Définissez un modèle de fonction de transfert :
Exécuter
In[]:=
dcMotor=TransferFunctionModel[{{{.01}},.0001+(.1+.01s)(1+.5s)},s]
Créez un tracé de Nyquist pour le système :
Exécuter
In[]:=
NyquistPlot[dcMotor]
Calculez un régulateur PID pour le modèle :
Exécuter
In[]:=
pid=PIDTune[dcMotor,"PID","Data"]
Calculez la réponse à une entrée en étape d’unités :
Exécuter
In[]:=
motorResponse=OutputResponse[pid["ReferenceOutput"],UnitStep[t],{t,0,5}]
Tracez la réponse :
Exécuter
In[]:=
Plot[motorResponse,{t,0,5},PlotRange->All]

Modélisez des systèmes avec des délais temporels

Spécifiez un système avec un délai temporel :
Exécuter
In[]:=
delayEqn=mx''[t]+cx'[t]+kx[t]-α(f[t]+x[t]-x[t-τ])/.τ->
2π
ω
Construisez un modèle espace-état symbolique :
Exécuter
In[]:=
latheModel=StateSpaceModel[delayEqn,{x[t],x'[t]},f[t],x[t],t,SystemsModelLabels{"f","x",{"x","x'"}}]
Spécifiez les paramètres numériques et un modèle numérique :
Exécuter
In[]:=
latheParams={m0.75,ω3,α->10,k0.1,c5,τ3};​​numericModel=latheModel/.latheParams
Créez un modèle approximatif sans le délai :
Exécuter
In[]:=
approximateModel=SystemsModelDelayApproximate[numericModel,0]
Visualisez la réponse fréquentielle des systèmes :
Exécuter
In[]:=
BodePlot[{numericModel,approximateModel},PlotLegends->{"Delay","Delay-Free"}]
Comparez la réponse de sortie des deux modèles à la même entrée :
Exécuter
In[]:=
responses=Table[OutputResponse[system,UnitStep[t],{t,0,30}],{system,{numericModel,approximateModel}}];​​Plot[responses,{t,0,30},PlotRangeAll,PlotLegends{"Delay","Delay-Free"}]

Concevez le contrôleur d’un régulateur

Définissez un modèle espace-état affine et le point d’équilibre souhaité
x
0
 :
Exécuter
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]
Spécifiez l’entrée de feedback :
Exécuter
In[]:=
feedbackModel="InputModel"->AffineStateSpaceModel[electromagnetModel,Automatic,Automatic,Automatic,None],"FeedbackInputs"->1
Calculez le contrôleur du régulateur :
Exécuter
In[]:=
controllerData=LQRegulatorGains[feedbackModel,{DiagonalMatrix[{.1,.1,.1}],{{5}}},"Data"]
Obtenez le système en boucle fermée :
Exécuter
In[]:=
closedSystem=controllerData["ClosedLoopSystem"]//Simplify
Calculez la réponse à l’état du système en boucle fermée :
Exécuter
In[]:=
emResponses=StateResponse[{closedSystem,{0.8,0,0}},0,{t,0,2}]
Visualisez la réponse qui se rapproche de l’équilibre souhaité :
Exécuter
In[]:=
Plot{emResponses[[1]],
x
0
/.pars},{t,0,2},

Obtenez le modèle du contrôleur :
Exécuter
In[]:=
emController=controllerData["ControllerModel"]
Tracez l’effort du contrôleur :
Exécuter
In[]:=
effort=OutputResponse[emController,Join[{0},emResponses],{t,0,2}];​​Plot[effort,{t,0,2},PlotRange->All]

Concevez le contrôleur prédictif d’un modèle

Calculez le modèle d’un contrôleur prédictif à partir d’une fonction de coût et de poids spécifiés :
Exécuter
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
Calculez le système en boucle fermée :
Exécuter
In[]:=
csys=ModelPredictiveController
0.1
0
0
1
-0.1
1
1
0
0
1
,cost,constraints,"ClosedLoopSystem"
Tracez la réponse à un ensemble de conditions initiales non nulles :
Exécuter
In[]:=
ListStepPlot[OutputResponse[{csys,<|1->{1,-1}|>},PadRight[{0,0.8},10]],PlotRange->All]

Modélisez des systèmes biochimiques et plus encore

Téléchargez la bibliothèque Bio Chem à partir du magasin de bibliothèques Modelica de System Modeler. Ensuite, suivez l’un des exemples suivants :
◼
  • Sélection de la dose pour les essais de médicaments
    • ◼
  • Estimation de la fonction hépatique
    • ◼
  • Phosphorylation des récepteurs de l’insuline