Wolfram Sistemas de control | Ejemplos a probar

Edite y ejecute cualquier pieza de código haciendo clic dentro del código y presionando
+
.
Modele, diseñe, implemente. Modele el entorno. Diseñe un controlador. Implemente al mundo real. Todo en un flujo de trabajo altamente integrado, desarrollado para estudiantes y profesionales.

Especifique y convierta modelos

Defina un modelo no lineal de espacio de estados a partir de ecuaciones diferenciales no lineales:
Ejecutar
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]
Linealice el modelo:
Ejecutar
In[]:=
linearModel=StateSpaceModel[nonlinearModel]
Especifique el modelo de espacio de estados directamente desde matrices de espacio de estados:
Ejecutar
In[]:=
StateSpaceModel
0
3
3
-1
,
-1
0
,(
1
0
)
Convierta en un modelo de función de transferencia:
Ejecutar
In[]:=
TransferFunctionModel[linearModel,s]
Discretice un modelo de tiempo continuo:
Ejecutar
In[]:=
ToDiscreteTimeModel[linearModel,0.5,Method->"ZeroOrderHold"]

Diseñe un controlador proporcional integral diferencial (PID)

Defina un modelo de función de transferencia:
Ejecutar
In[]:=
dcMotor=TransferFunctionModel[{{{.01}},.0001+(.1+.01s)(1+.5s)},s]
Cree un diagrama de Nyquist del sistema:
Ejecutar
In[]:=
NyquistPlot[dcMotor]
Calcule un controlador PID para el modelo:
Ejecutar
In[]:=
pid=PIDTune[dcMotor,"PID","Data"]
Calcule la respuesta a una entrada de paso unidad:
Ejecutar
In[]:=
motorResponse=OutputResponse[pid["ReferenceOutput"],UnitStep[t],{t,0,5}]
Represente la respuesta:
Ejecutar
In[]:=
Plot[motorResponse,{t,0,5},PlotRange->All]

Modele sistemas con retardos de tiempo

Especifique un sistema con un retardo de tiempo:
Ejecutar
In[]:=
delayEqn=mx''[t]+cx'[t]+kx[t]-α(f[t]+x[t]-x[t-τ])/.τ->
2π
ω
Construya un modelo simbólico de espacio de estados:
Ejecutar
In[]:=
latheModel=StateSpaceModel[delayEqn,{x[t],x'[t]},f[t],x[t],t,SystemsModelLabels{"f","x",{"x","x'"}}]
Especifique parámetros numéricos y un modelo numérico:
Ejecutar
In[]:=
latheParams={m0.75,ω3,α->10,k0.1,c5,τ3};​​numericModel=latheModel/.latheParams
Cree un modelo aproximado sin el retardo:
Ejecutar
In[]:=
approximateModel=SystemsModelDelayApproximate[numericModel,0]
Visualice la respuesta de frecuencia de los sistemas:
Ejecutar
In[]:=
BodePlot[{numericModel,approximateModel},PlotLegends->{"Delay","Delay-Free"}]
Compare la respuesta de salida de los dos modelos a la misma entrada:
Ejecutar
In[]:=
responses=Table[OutputResponse[system,UnitStep[t],{t,0,30}],{system,{numericModel,approximateModel}}];​​Plot[responses,{t,0,30},PlotRangeAll,PlotLegends{"Delay","Delay-Free"}]

Diseñe un controlador regulador

Defina un modelo afín de espacio de estados y un punto de equilibrio deseado
x
0
:
Ejecutar
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]
Especifique la entrada de retroalimentación:
Ejecutar
In[]:=
feedbackModel="InputModel"->AffineStateSpaceModel[electromagnetModel,Automatic,Automatic,Automatic,None],"FeedbackInputs"->1
Calcule el controlador regulador:
Ejecutar
In[]:=
controllerData=LQRegulatorGains[feedbackModel,{DiagonalMatrix[{.1,.1,.1}],{{5}}},"Data"]
Obtenga el sistema de bucle cerrado:
Ejecutar
In[]:=
closedSystem=controllerData["ClosedLoopSystem"]//Simplify
Calcule la respuesta de estado al sistema de bucle cerrado:
Ejecutar
In[]:=
emResponses=StateResponse[{closedSystem,{0.8,0,0}},0,{t,0,2}]
Visualice la respuesta aproximándose al equilibrio deseado:
Ejecutar
In[]:=
Plot{emResponses[[1]],
x
0
/.pars},{t,0,2},

Obtenga el modelo del controlador:
Ejecutar
In[]:=
emController=controllerData["ControllerModel"]
Represente el esfuerzo del controlador:
Ejecutar
In[]:=
effort=OutputResponse[emController,Join[{0},emResponses],{t,0,2}];​​Plot[effort,{t,0,2},PlotRange->All]

Diseñe un controlador predictivo por modelo

Calcule un controlador predictivo por modelo a partir d euna función costo y ponderaciones especificadas:
Ejecutar
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
Calcule el sistema de bucle cerrado:
Ejecutar
In[]:=
csys=ModelPredictiveController
0.1
0
0
1
-0.1
1
1
0
0
1
,cost,constraints,"ClosedLoopSystem"
Represente la respuesta a un conjunto de condiciones iniciales distintas de cero:
Ejecutar
In[]:=
ListStepPlot[OutputResponse[{csys,<|1->{1,-1}|>},PadRight[{0,0.8},10]],PlotRange->All]

Modele sistemas bioquímicos y más

Descargue la biblioteca Bio Chem desde la Tienda de bibliotecas Modelica de System Modeler y siga cualquiera de estos ejemplos:
◼
  • Selección de dosis para pruebas de medicamentos
    • ◼
  • Estimación de la función hepática
    • ◼
  • Fosforilación de receptores de insulina