Discrete-time or continuous-time PID controller - Simulink - 金宝app,下载188bet金宝搏,金宝搏官方网站

Library:
Simulink / Discrete
高密度脂蛋白编码器/离散
HDL Coder / HDL Floating Point Operations

Ports

Input

`Port_1( u )`— Error signal input
scalar | vector

Difference between a reference signal and the output of the system under control, as shown.

`P`— Proportional gain
scalar | vector

Proportional gain, provided from a source external to the block. External gain input is useful, for example, when you want to map a different PID parameterization to the PID gains of the block. You can also use external gain input to implement gain-scheduled PID control. In gain-scheduled control, you determine the PID coefficients by logic or other calculation in your model and feed them to the block.

Dependencies

To enable this port, setController parameters Sourcetoexternal.

`I`— Integral gain
scalar | vector

Integral gain, provided from a source external to the block. External gain input is useful, for example, when you want to map a different PID parameterization to the PID gains of the block. You can also use external gain input to implement gain-scheduled PID control. In gain-scheduled control, you determine the PID coefficients by logic or other calculation in your model and feed them to the block.

When you supply gains externally, time variations in the integral gain are also integrated. This result occurs because of the way the PID gains are implemented within the block. For details, see theController parameters Sourceparameter.

Dependencies

To enable this port, setController parameters Sourcetoexternal, and setControllerto a controller type that has integral action.

`D`— Derivative gain
scalar | vector

Derivative gain, provided from a source external to the block. External gain input is useful, for example, when you want to map a different PID parameterization to the PID gains of the block. You can also use external gain input to implement gain-scheduled PID control. In gain-scheduled control, you determine the PID coefficients by logic or other calculation in your model and feed them to the block.

When you supply gains externally, time variations in the derivative gain are also differentiated. This result occurs because of the way the PID gains are implemented within the block. For details, see theController parameters Sourceparameter.

Dependencies

To enable this port, setController parameters Sourcetoexternal, and setControllerto a controller type that has derivative action.

`N`— Filter coefficient
scalar | vector

Derivative filter coefficient, provided from a source external to the block. External coefficient input is useful, for example, when you want to map a different PID parameterization to the PID gains of the block. You can also use the external input to implement gain-scheduled PID control. In gain-scheduled control, you determine the PID coefficients by logic or other calculation in your model and feed them to the block.

Dependencies

To enable this port, setController parameters Sourcetoexternal, and setControllerto a controller type that has a filtered derivative.

`Reset`- - - - - -克斯特nal reset trigger
scalar

Trigger to reset the integrator and filter to their initial conditions. The value of theExternal resetparameter determines whether reset occurs on a rising signal, a falling signal, or a level signal. The port icon indicates the selected trigger type. For example, the following illustration shows a continuous-time PID block withExternal resetset torising.

When the trigger occurs, the block resets the integrator and filter to the initial conditions specified by theIntegrator Initial conditionandFilter Initial conditionparameters or theI₀andD₀ports.

Note

To be compliant with the Motor Industry Software Reliability Association (MISRA^®) software standard, your model must use Boolean signals to drive the external reset ports of thePID controllerblock.

Dependencies

To enable this port, setExternal resetto any value other thannone.

`I₀`— Integrator initial condition
scalar | vector

Integrator initial condition, provided from a source external to the block.

Dependencies

To enable this port, setInitial conditions Sourcetoexternal, and setControllerto a controller type that has integral action.

`D₀`— Filter initial condition
scalar | vector

Initial condition of the derivative filter, provided from a source external to the block.

Dependencies

To enable this port, setInitial conditions Sourcetoexternal, and setControllerto a controller type that has derivative action.

`TR`— Tracking signal
scalar | vector

Signal for controller output to track. When signal tracking is active, the difference between the tracking signal and the block output is fed back to the integrator input. Signal tracking is useful for implementing bumpless control transfer in systems that switch between two controllers. It can also be useful to prevent block windup in multiloop control systems. For more information, see theEnable tracking modeparameter.

Dependencies

To enable this port, select theEnable tracking modeparameter.

Output

expand all

`Port_1( y )`— Controller output
scalar | vector

Controller output, generally based on a sum of the input signal, the integral of the input signal, and the derivative of the input signal, weighted by the proportional, integral, and derivative gain parameters. A first-order pole filters the derivative action. Which terms are present in the controller signal depends on what you select for theControllerparameter. The base controller transfer function for the current settings is displayed in theCompensator formulasection of the block parameters and under the mask. Other parameters modify the block output, such as saturation limits specified by theUpper LimitandLower Limitsaturation parameters.

The controller output is a vector signal when any of the inputs is a vector signal. In that case, the block acts asNindependent PID controllers, whereNis the number of signals in the input vector.

Parameters

expand all

`Controller`——控制器类型
`PID`(default) |`PI`|`PD`|`P`|`I`

Specify which of the proportional, integral, and derivative terms are in the controller.

PID: Proportional, integral, and derivative action.
PI: Proportional and integral action only.
PD: Proportional and derivative action only.
P: Proportional action only.
I: Integral action only.

Tip

The controller transfer function for the current setting is displayed in theCompensator formulasection of the block parameters and under the mask.

Programmatic Use

Block Parameter:Controller

Type:string, character vector

Values:"PID","PI","PD","P","I"

Default:"PID"

`Form`— Controller structure
`Parallel`(default) |`Ideal`

Specify whether the controller structure is parallel or ideal.

Parallel

The controller output is the sum of the proportional, integral, and derivative actions, weighted independently byP,I, andD, respectively. For example, for a continuous-time parallel-form PID controller, the transfer function is:

$C_{p a r} (s) = P + I (\frac{1}{s}) + D (\frac{N s}{s + N}) .$

For a discrete-time parallel-form controller, the transfer function is:

$C_{p a r} (z) = P + I α (z) + D [\frac{N}{1 + N β (z)}],$

where theIntegrator methodandFilter methodparameters determineα(z) andβ(z), respectively.

Ideal

The proportional gainPacts on the sum of all actions. For example, for a continuous-time ideal-form PID controller, the transfer function is:

$C_{i d} (s) = P [1 + I (\frac{1}{s}) + D (\frac{N s}{s + N})] .$

For a discrete-time ideal-form controller, the transfer function is:

$C_{i d} (z) = P [1 + I α (z) + D \frac{N}{1 + N β (z)}],$

where theIntegrator methodandFilter methodparameters determinea(z) andb(z), respectively.

Tip

The controller transfer function for the current settings is displayed in theCompensator formulasection of the block parameters and under the mask.

Programmatic Use

Block Parameter:Controller

Type:string, character vector

Values:"Parallel","Ideal"

Default:"Parallel"

`Time domain`— Specify discrete-time or continuous-time controller
`Discrete-time`(default) |`Continuous-time`

When you selectDiscrete-time, it is recommended that you specify an explicit sample time for the block. See theSample time (-1 for inherited)parameter. SelectingDiscrete-timealso enables theIntegrator method, andFilter methodparameters.

When thePID Controllerblock is in a model with synchronous state control (see theState Controlblock), you cannot selectContinuous-time.

Note

ThePID ControllerandDiscrete PID Controllerblocks are identical except for the default value of this parameter.

Programmatic Use

Block Parameter:TimeDomain

Type:string, character vector

Values:"Continuous-time","Discrete-time"

Default:"Continuous-time"

`Sample time (-1 for inherited)`— Discrete interval between samples
–1 (default) | positive scalar

Specify a sample time by entering a positive scalar value, such as 0.1. The default discrete sample time of –1 means that the block inherits its sample time from upstream blocks. However, it is recommended that you set the controller sample time explicitly, especially if you expect the sample time of upstream blocks to change. The effect of the controller coefficients P, I, D, and N depend on the sample time. Thus, for a given set of coefficient values, changing the sample time changes the performance of the controller.

SeeSpecify Sample Timefor more information.

To implement a continuous-time controller, setTime domaintoContinuous-time.

Tip

If you want to run the block with an externally specified or variable sample time, set this parameter to –1 and put the block in aTriggered Subsystem. Then, trigger the subsystem at the desired sample time.

Dependencies

To enable this parameter, setTime domaintoDiscrete-time.

Programmatic Use

Block Parameter:SampleTime

Type:scalar

Values:-1,阿宝sitive scalar

Default:-1

`Integrator method`— Method for computing integral in discrete-time controller
`Forward Euler`(default) |`Backward Euler`|`Trapezoidal`

In discrete time, the integral term of the controller transfer function isIα(z), whereα(z) depends on the integrator method you specify with this parameter.

Forward Euler

Forward rectangular (left-hand) approximation,

$α (z) = \frac{T_{s}}{z - 1} .$

This method is best for small sampling times, where the Nyquist limit is large compared to the bandwidth of the controller. For larger sampling times, theForward Eulermethod can result in instability, even when discretizing a system that is stable in continuous time.

Backward Euler

Backward rectangular (right-hand) approximation,

$α (z) = \frac{T_{s} z}{z - 1} .$

An advantage of theBackward Eulermethod is that discretizing a stable continuous-time system using this method always yields a stable discrete-time result.

Trapezoidal

Bilinear approximation,

$α (z) = \frac{T_{s}}{2} \frac{z + 1}{z - 1} .$

An advantage of theTrapezoidalmethod is that discretizing a stable continuous-time system using this method always yields a stable discrete-time result. Of all available integration methods, theTrapezoidal频率-间收益率最接近的匹配方法domain properties of the discretized system and the corresponding continuous-time system.

Tip

The controller formula for the current setting is displayed in theCompensator formulasection of the block parameters and under the mask.

Note

For theBackwardEulerorTrapezoidalmethods, you cannot generate HDL code for the block if either:

Limit output是选取ected andAnti-Windup Methodis anything other thannone.
Enable tracking mode是选取ected.

For more information about discrete-time integration, see theDiscrete-Time Integratorblock reference page.

Dependencies

To enable this parameter, setTime DomaintoDiscrete-timeand setControllerto a controller type with integral action.

Programmatic Use

Block Parameter:IntegratorMethod

Type:string, character vector

Values:"Forward Euler","Backward Euler","Trapezoidal"

Default:"Forward Euler"

`Filter method`— Method for computing derivative in discrete-time controller
`Forward Euler`(default) |`Backward Euler`|`Trapezoidal`

In discrete time, the derivative term of the controller transfer function is:

$D [\frac{N}{1 + N α (z)}],$

whereα(z) depends on the filter method you specify with this parameter.

Forward Euler

Forward rectangular (left-hand) approximation,

$α (z) = \frac{T_{s}}{z - 1} .$

This method is best for small sampling times, where the Nyquist limit is large compared to the bandwidth of the controller. For larger sampling times, theForward Eulermethod can result in instability, even when discretizing a system that is stable in continuous time.

Backward Euler

Backward rectangular (right-hand) approximation,

$α (z) = \frac{T_{s} z}{z - 1} .$

An advantage of theBackward Eulermethod is that discretizing a stable continuous-time system using this method always yields a stable discrete-time result.

Trapezoidal

Bilinear approximation,

$α (z) = \frac{T_{s}}{2} \frac{z + 1}{z - 1} .$

An advantage of theTrapezoidalmethod is that discretizing a stable continuous-time system using this method always yields a stable discrete-time result. Of all available integration methods, theTrapezoidal频率-间收益率最接近的匹配方法domain properties of the discretized system and the corresponding continuous-time system.

Tip

The controller formula for the current setting is displayed in theCompensator formulasection of the block parameters and under the mask.

For more information about discrete-time integration, see theDiscrete-Time Integratorblock reference page.

Dependencies

To enable this parameter, setTime DomaintoDiscrete-timeand setControllerto a controller type with derivative action.

Programmatic Use

Block Parameter:FilterMethod

Type:string, character vector

Values:"Forward Euler","Backward Euler","Trapezoidal"

Default:"Forward Euler"

Main

`Source`— Source for controller gains and filter coefficient
internal (default) | external

Enabling external inputs for the parameters allows you to compute PID gains and filter coefficients externally to the block and provide them to the block as signal inputs.

internal

Specify the controller gains and filter coefficient using the block parametersP,I,D, andN.

external

Specify the PID gains and filter coefficient externally using block inputs. An additional input port appears on the block for each parameter that is required for the current controller type.

外部输入useful, for example, when you want to map a different PID parameterization to the PID gains of the block. You can also use external gain input to implement gain-scheduled PID control. In gain-scheduled control, you determine the PID gains by logic or other calculation in your model and feed them to the block.

When you supply gains externally, time variations in the integral and derivative gain values are integrated and differentiated, respectively. This result occurs because in both continuous time and discrete time, the gains are applied to the signal before integration or differentiation. For example, for a continuous-time PID controller with external inputs, the integrator term is implemented as shown in the following illustration.

Within the block, the input signaluis multiplied by the externally supplied integrator gain,I, before integration. This implementation yields:

$y_{i} = \int u I d t .$

Thus, the integrator gain is included in the integral. Similarly, in the derivative term of the block, multiplication by the derivative gain precedes the differentiation, which causes the derivative gainDto be differentiated.

Programmatic Use

Block Parameter:ControllerParametersSource

Type:string, character vector

Values:"internal","external"

Default:"internal"

`Proportional (P)`— Proportional gain
1 (default) | scalar | vector

Specify a finite, real gain value for the proportional gain. WhenController formis:

Parallel— Proportional action is independent of the integral and derivative actions. For instance, for a continuous-time parallel PID controller, the transfer function is:

$C_{p a r} (s) = P + I (\frac{1}{s}) + D (\frac{N s}{s + N}) .$

For a discrete-time parallel-form controller, the transfer function is:

$C_{p a r} (z) = P + I α (z) + D [\frac{N}{1 + N β (z)}],$

where theIntegrator methodandFilter methodparameters determineα(z) andβ(z), respectively.
Ideal— The proportional gain multiples the integral and derivative terms. For instance, for a continuous-time ideal PID controller, the transfer function is:

$C_{i d} (s) = P [1 + I (\frac{1}{s}) + D (\frac{N s}{s + N})] .$

For a discrete-time ideal-form controller, the transfer function is:

$C_{i d} (z) = P [1 + I α (z) + D \frac{N}{1 + N β (z)}],$

where theIntegrator methodandFilter methodparameters determineα(z) andβ(z), respectively.

Tunable:Yes

Dependencies

To enable this parameter, in theMaintab, set the controller-parametersSourcetointernaland setControllertoPID,PD,PI, orP.

Programmatic Use

Block Parameter:P

Type:scalar, vector

Default:1

`Integral (I)`— Integral gain
1 (default) | scalar | vector

Specify a finite, real gain value for the integral gain.

Tunable:Yes

Dependencies

To enable this parameter, in theMaintab, set the controller-parametersSourcetointernal, and setControllerto a type that has integral action.

Programmatic Use

Block Parameter:I

Type:scalar, vector

Default:1

`Derivative (D)`— Derivative gain
0 (default) | scalar | vector

Specify a finite, real gain value for the derivative gain.

Tunable:Yes

Dependencies

To enable this parameter, in theMaintab, set the controller-parametersSourcetointernal, and setControllertoPIDorPD.

Programmatic Use

Block Parameter:D

Type:scalar, vector

Default:0

`Use filtered derivative`— Apply filter to derivative term
`on`(default) |`off`

For discrete-time PID controllers only, clear this option to replace the filtered derivative with an unfiltered discrete-time differentiator. When you do so, the derivative term of the controller transfer function becomes:

$D \frac{z - 1}{z T_{s}} .$

For continuous-time PID controllers, the derivative term is always filtered.

Dependencies

To enable this parameter, setTime domaintoDiscrete-time, and setControllerto a type that has derivative action.

Programmatic Use

Block Parameter:UseFilter

Type:string, character vector

Values:"on","off"

Default:"on"

`Filter coefficient (N)`— Derivative filter coefficient
100 (default) | scalar | vector

Specify a finite, real gain value for the filter coefficient. The filter coefficient determines the pole location of the filter in the derivative action of the block. The location of the filter pole depends on theTime domainparameter.

WhenTime domainisContinuous-time, the pole location iss = -N.

WhenTime domainisDiscrete-time, the pole location depends on theFilter methodparameter.

Filter Method	Location of Filter Pole
`Forward Euler`	$z_{p o l e} = 1 - N T_{s}$
`Backward Euler`	$z_{p o l e} = \frac{1}{1 + N T_{s}}$
`Trapezoidal`	$z_{p o l e} = \frac{1 - N T_{s} / 2}{1 + N T_{s} / 2}$

The block does not supportN = Inf(ideal unfiltered derivative). When theTime domainisDiscrete-time, you can clearUse filtered derivativeto remove the derivative filter.

Tunable:Yes

Dependencies

To enable this parameter, in theMaintab, set the controller-parametersSourcetointernaland setControllertoPIDorPD.

Programmatic Use

Block Parameter:N

Type:scalar, vector

Default:100

`Select tuning method`— Tool for automatic tuning of controller coefficients
`Transfer Function Based (PID Tuner App)`(default) |`Frequency Response Based`

If you haveSimulink Control Designsoftware, you can automatically tune the PID coefficients. To do so, use this parameter to select a tuning tool, and clickTune.

Transfer Function Based (PID Tuner App): UsePID Tuner, which lets you interactively tune PID coefficients while examining relevant system responses to validate performance. By default,PID Tunerworks with a linearization of your plant model. For models that cannot be linearized, you can tune PID coefficients against a plant model estimated from simulated or measured response data. For more information, seeIntroduction to Model-Based PID Tuning in Simulink(Simulink Control Design).
Frequency Response Based: UseFrequency Response Based PID Tuner, which tunes PID controller coefficients based on frequency-response estimation data obtained by simulation. This tuning approach is especially useful for plants that are not linearizable or that linearize to zero. For more information, seeDesign PID Controller from Plant Frequency-Response Data(Simulink Control Design).

Both of these tuning methods assume a single-loop control configuration.Simulink Control Designsoftware includes other tuning approaches that suit more complex configurations. For information about other ways to tune aPID Controllerblock, seeChoose a Control Design Approach(Simulink Control Design).

`Enable zero-crossing detection`— Detect zero crossings on reset and on entering or leaving a saturation state
`on`(default) |`off`

Zero-crossing detection can accurately locate signal discontinuities without resorting to excessively small time steps that can lead to lengthy simulation times. If you selectLimit outputor activateExternal resetin your PID Controller block, activating zero-crossing detection can reduce computation time in your simulation. Selecting this parameter activates zero-crossing detection:

At initial-state reset
When entering an upper or lower saturation state
When leaving an upper or lower saturation state

关于零的更多信息crossing detection, seeZero-Crossing Detection.

Programmatic Use

Block Parameter:ZeroCross

Type:string, character vector

Values:"on","off"

Default:"on"

Initialization

`Source`— Source for integrator and derivative initial conditions
`internal`(default) |`external`

Simulink uses initial conditions to initialize the integrator and derivative-filter (or the unfiltered derivative) output at the start of a simulation or at a specified trigger event. (See theExternal resetparameter.) These initial conditions determine the initial block output. Use this parameter to select how to supply the initial condition values to the block.

internal: Specify the initial conditions using theIntegrator Initial conditionandFilter Initial conditionparameters. IfUse filtered derivativeis not selected, use theDifferentiatorparameter to specify the initial condition for the unfiltered differentiator instead of a filter initial condition.
external: Specify the initial conditions externally using block inputs. Additional input portsI_oandD_oappear on the block. IfUse filtered derivativeis not selected, supply the initial condition for the unfiltered differentiator atD_oinstead of a filter initial condition.

Programmatic Use

Block Parameter:InitialConditionSource

Type:string, character vector

Values:"internal","external"

Default:"internal"

`Integrator`— Integrator initial condition
0 (default) | scalar | vector

Simulink uses the integrator initial condition to initialize the integrator at the start of a simulation or at a specified trigger event (seeExternal reset). The integrator initial condition and the filter initial condition determine the initial output of thePID controllerblock.

The integrator initial condition cannot beNaNorInf.

Dependencies

To use this parameter, in theInitializationtab, setSourcetointernal, and setControllerto a type that has integral action.

Programmatic Use

Block Parameter:InitialConditionForIntegrator

Type:scalar, vector

Default:0

`Filter`— Filter initial condition
0 (default) | scalar | vector

Simulink uses the filter initial condition to initialize the derivative filter at the start of a simulation or at a specified trigger event (seeExternal reset). The integrator initial condition and the filter initial condition determine the initial output of thePID controllerblock.

The filter initial condition cannot beNaNorInf.

Dependencies

To use this parameter, in theInitializationtab, setSourcetointernal, and use a controller that has a derivative filter.

Programmatic Use

Block Parameter:InitialConditionForFilter

Type:scalar, vector

Default:0

`Differentiator`— Initial condition for unfiltered derivative
0 (default) | scalar | vector

When you use an unfiltered derivative, Simulink uses this parameter to initialize the differentiator at the start of a simulation or at a specified trigger event (seeExternal reset). The integrator initial condition and the derivative initial condition determine the initial output of thePID controllerblock.

The derivative initial condition cannot beNaNorInf.

Dependencies

To use this parameter, setTime domaintoDiscrete-time, clear theUse filtered derivativecheck box, and in theInitializationtab, setSourcetointernal.

Programmatic Use

Block Parameter:DifferentiatorICPrevScaledInput

Type:scalar, vector

Default:0

`Initial condition setting`— Location at which initial condition is applied
`State (most efficient)`(default) |`Output`

Use this parameter to specify whether to apply theIntegrator Initial conditionandFilter Initial conditionparameter to the corresponding block state or output. You can change this parameter at the command line only, usingset_paramto set theInitialConditionSettingparameter of the block.

State (most efficient): Use this option in all situations except when the block is in a triggered subsystem or a function-call subsystem and simplified initialization mode is enabled.
Output: Use this option when the block is in a triggered subsystem or a function-call subsystem and simplified initialization mode is enabled.

For more information about theInitial condition settingparameter, see theDiscrete-Time Integratorblock.

This parameter is only accessible through programmatic use.

Programmatic Use

Block Parameter:InitialConditionSetting

Type:string, character vector

Values:"state","output"

Default:"state"

`External reset`— Trigger for resetting integrator and filter values
`none`(default) |`rising`|`falling`|`either`|`level`

Specify the trigger condition that causes the block to reset the integrator and filter to initial conditions. (IfUse filtered derivativeis not selected, the trigger resets the integrator and differentiator to initial conditions.) Selecting any option other thannoneenables theResetport on the block for the external reset signal.

none

The integrator and filter (or differentiator) outputs are set to initial conditions at the beginning of simulation, and are not reset during simulation.

rising

Reset the outputs when the reset signal has a rising edge.

falling

Reset the outputs when the reset signal has a falling edge.

either

Reset the outputs when the reset signal either rises or falls.

level

Reset the outputs when the reset signal either:

Is nonzero at the current time step
Changes from nonzero at the previous time step to zero at the current time step

This option holds the outputs to the initial conditions while the reset signal is nonzero.

Dependencies

To enable this parameter, setControllerto a type that has derivative or integral action.

Programmatic Use

Block Parameter:ExternalReset

Type:string, character vector

Values:"none","rising","falling","either","level"

Default:"none"

`Ignore reset when linearizing`— Force linearization to ignore reset
`off`(default) |`on`

Select to force Simulink andSimulink Control Designlinearization commands to ignore any reset mechanism specified in theExternal resetparameter. Ignoring reset states allows you to linearize a model around an operating point even if that operating point causes the block to reset.

Programmatic Use

Block Parameter:IgnoreLimit

Type:string, character vector

Values:"off","on"

Default:"off"

`Enable tracking mode`— Activate signal tracking
`off`(default) |`on`

Signal tracking lets the block output follow a tracking signal that you provide at theTRport. When signal tracking is active, the difference between the tracking signal and the block output is fed back to the integrator input with a gainKt, specified by theTracking gain (Kt)parameter. Signal tracking has several applications, including bumpless control transfer and avoiding windup in multiloop control structures.

Bumpless control transfer

Use signal tracking to achieve bumpless control transfer in systems that switch between two controllers. Suppose you want to transfer control between a PID controller and another controller. To do so, connecting the controller output to theTR输入下图所示。

For more information, seeBumpless Control Transfer.

Multiloop control

Use signal tracking to prevent block windup in multiloop control approaches, as in the following model.

The Inner Loop subsystem contains the blocks shown in the following diagram.

Because the PID controller tracks the output of the inner loop, its output never exceeds the saturated inner-loop output. For more details, seePrevent Block Windup in Multiloop Control.

Dependencies

To enable this parameter, setControllerto a type that has integral action.

Programmatic Use

Block Parameter:TrackingMode

Type:string, character vector

Values:"off","on"

Default:"off"

`Tracking coefficient (Kt)`— Gain of signal-tracking feedback loop
1 (default) | scalar

When you selectEnable tracking mode, the difference between the signalTRand the block output is fed back to the integrator input with a gainKt. Use this parameter to specify the gain in that feedback loop.

Dependencies

To enable this parameter, selectEnable tracking mode.

Programmatic Use

Block Parameter:Kt

Type:scalar

Default:1

Output saturation

`Limit Output`— Limit block output to specified saturation values
`off`(default) |`on`

Activating this option limits the block output internally to the block, so that you do not need a separateSaturationblock after the controller. It also allows you to activate the anti-windup mechanism built into the block (see theAnti-windup方法parameter). Specify the saturation limits using theLower saturation limitandUpper saturation limitparameters.

Programmatic Use

Block Parameter:LimitOutput

Type:string, character vector

Values:"off","on"

Default:"off"

`Upper limit`— Upper saturation limit for block output
`Inf`(default) | scalar

Specify the upper limit for the block output. The block output is held at theUpper saturation limitwhenever the weighted sum of the proportional, integral, and derivative actions exceeds that value.

Dependencies

To enable this parameter, selectLimit output.

Programmatic Use

Block Parameter:UpperSaturationLimit

Type:scalar

Default:Inf

`Lower limit`— Lower saturation limit for block output
`-Inf`(default) | scalar

Specify the lower limit for the block output. The block output is held at theLower saturation limitwhenever the weighted sum of the proportional, integral, and derivative actions goes below that value.

Dependencies

To enable this parameter, selectLimit output.

Programmatic Use

Block Parameter:LowerSaturationLimit

Type:scalar

Default:-Inf

`Ignore saturation when linearizing`— Force linearization to ignore output limits
`off`(default) |`on`

Force Simulink andSimulink Control Designlinearization commands to ignore block output limits specified in theUpper limitandLower limitparameters. Ignoring output limits allows you to linearize a model around an operating point even if that operating point causes the block to exceed the output limits.

Dependencies

To enable this parameter, select theLimit outputparameter.

Programmatic Use

Block Parameter:LinearizeAsGain

Type:string, character vector

Values:"off","on"

Default:"off"

`Anti-windup方法`— Integrator anti-windup method
`none`(default) |`back-calculation`|`clamping`

When you selectLimit outputand the weighted sum of the controller components exceeds the specified output limits, the block output holds at the specified limit. However, the integrator output can continue to grow (integrator windup), increasing the difference between the block output and the sum of the block components. In other words, the internal signals in the block can be unbounded even if the output appears bounded by saturation limits. Without a mechanism to prevent integrator windup, two results are possible:

If the sign of the input signal never changes, the integrator continues to integrate until it overflows. The overflow value is the maximum or minimum value for the data type of the integrator output.
If the sign of the input signal changes once the weighted sum has grown beyond the output limits, it can take a long time to unwind the integrator and return the weighted sum within the block saturation limit.

In either case, controller performance can suffer. To combat the effects of windup without an anti-windup mechanism, it may be necessary to detune the controller (for example, by reducing the controller gains), resulting in a sluggish controller. To avoid this problem, activate an anti-windup mechanism using this parameter.

none

Do not use an anti-windup mechanism.

back-calculation

Unwind the integrator when the block output saturates by feeding back to the integrator the difference between the saturated and unsaturated control signal. The following diagram represents the back-calculation feedback circuit for a continuous-time controller. To see the actual feedback circuit for your controller configuration, right-click on the block and selectMask>Look Under Mask.

Use theBack-calculation coefficient (Kb)parameter to specify the gain of the anti-windup feedback circuit. It is usually satisfactory to setKb = I, or for controllers with derivative action,Kb = sqrt(I*D). Back-calculation can be effective for plants with relatively large dead time[1].

clamping

Integration stops when the sum of the block components exceeds the output limits and the integrator output and block input have the same sign. Integration resumes when the sum of the block components exceeds the output limits and the integrator output and block input have opposite sign. Clamping is sometimes referred to as conditional integration.

Clamping can be useful for plants with relatively small dead times, but can yield a poor transient response for large dead times[1].

Dependencies

To enable this parameter, select theLimit outputparameter.

Programmatic Use

Block Parameter:AntiWindupMode

Type:string, character vector

Values:"none","back-calculation","clamping"

Default:"none"

`Back-calculation coefficient (Kb)`— Gain coefficient of anti-windup feedback loop
1 (default) | scalar

Theback-calculationanti-windup method unwinds the integrator when the block output saturates. It does so by feeding back to the integrator the difference between the saturated and unsaturated control signal. Use theBack-calculation coefficient (Kb)parameter to specify the gain of the anti-windup feedback circuit. For more information, see theAnti-windup方法parameter.

Dependencies

To enable this parameter, select theLimit outputparameter, and set theAnti-windup方法parameter toback-calculation.

Programmatic Use

Block Parameter:Kb

Type:scalar

Default:1

Data Types

The parameters in this tab are primarily of use in fixed-point code generation using Fixed-Point Designer™. They define how numeric quantities associated with the block are stored and processed when you generate code.

If you need to configure data types for fixed-point code generation, clickOpen Fixed-Point Tooland use that tool to configure the rest of the parameters in the tab. For information about using Fixed-Point Tool, seeAutoscaling Data Objects Using the Fixed-Point Tool(Fixed-Point Designer).

After you use Fixed-Point Tool, you can use the parameters in this tab to make adjustments to fixed-point data-type settings if necessary. For each quantity associated with the block, you can specify:

Floating-point or fixed-point data type, including whether the data type is inherited from upstream values in the block.
The minimum and maximum values for the quantity, which determine how the quantity is scaled for fixed-point representation.

For assistance in selecting appropriate values, clickto open the Data Type Assistant for the corresponding quantity. For more information, seeSpecify Data Types Using Data Type Assistant.

The specific quantities listed in the Data Types tab vary depending on how you configure the PID controller block. In general, you can configure data types for the following types of quantities:

Product output — Stores the result of a multiplication carried out under the block mask. For example,P product outputstores the output of the gain block that multiplies the block input with the proportional gainP.
Parameter — Stores the value of a numeric block parameter, such asP,I, orD.
Block output — Stores the output of a block that resides under the PID controller block mask. For example, useIntegrator outputto specify the data type of the output of the block called Integrator. This block resides under the mask in the Integrator subsystem, and computes integrator term of the controller action.
Accumulator — Stores values associated with a sum block. For example,SumI2 Accumulatorsets the data type of the accumulator associated with the sum block SumI2. This block resides under the mask in the Back Calculation subsystem of the Anti-Windup subsystem.

In general, you can find the block associated with any listed parameter by looking under the PID Controller block mask and examining its subsystems. You can also use the Model Explorer to search under the mask for the listed parameter name, such asSumI2. (SeeSearch and Edit Using Model Explorer.)

Matching Input and Internal Data Types

By default, all data types in the block are set toInherit: Inherit via internal rule. With this setting, Simulink chooses data types to balance numerical accuracy, performance, and generated code size, while accounting for the properties of the embedded target hardware.

Under some conditions, incompatibility can occur between data types within the block. For instance, in continuous time, the Integrator block under the mask can accept only signals of typedouble. If the block input signal is a type that cannot be converted todouble, such asuint16, the internal rules for type inheritance generate an error when you generate code.

To avoid such errors, you can use the Data Types settings to force a data type conversion. For instance, you can explicitly setP product output,I product output, andD product outputtodouble, ensuring that the signals reaching the continuous-time integrators are of typedouble.

In general, it is not recommended to use the block in continuous time for code generation applications. However, similar data type errors can occur in discrete time, if you explicitly set some values to data types that are incompatible with downstream signal constraints within the block. In such cases, use the Data Types settings to ensure that all data types are internally compatible.

Fixed-Point Operational Parameters

`Integer rounding mode`— Rounding mode for fixed-point operations
`Floor`(default) |`Ceiling`|`Convergent`|`Nearest`|`Round`|`Simplest`|`Zero`

Specify the rounding mode for fixed-point operations. For more information, seeRounding(Fixed-Point Designer).

Block parameters always round to the nearest representable value. To control the rounding of a block parameter, enter an expression using a MATLAB^®rounding function into the mask field.

Programmatic Use

Block Parameter:RndMeth

Type:character vector

Default:'Floor'

`Saturate on integer overflow`— Method of overflow action
`off`(default) |`on`

指定是否溢出饱和或包装。

off— Overflows wrap to the appropriate value that the data type can represent.
For example, the number 130 does not fit in a signed 8-bit integer and wraps to -126.
on— Overflows saturate to either the minimum or maximum value that the data type can represent.
For example, an overflow associated with a signed 8-bit integer can saturate to -128 or 127.

Tip

Consider selecting this check box when your model has a possible overflow and you want explicit saturation protection in the generated code.
Consider clearing this check box when you want to optimize efficiency of your generated code.
Clearing this check box also helps you to avoid overspecifying how a block handles out-of-range signals. For more information, seeCheck for Signal Range Errors.
When you select this check box, saturation applies to every internal operation on the block, not just the output or result.
In general, the code generation process can detect when overflow is not possible. In this case, the code generator does not produce saturation code.

Programmatic Use

Block Parameter:SaturateOnIntegerOverflow

Type:character vector

Values:'off' | 'on'

Default:'off'

`Lock data type settings against changes by the fixed-point tools`— Prevent fixed-point tools from overriding data types
`off`(default) |`on`

Select this parameter to prevent the fixed-point tools from overriding the data types you specify on this block. For more information, seeLock the Output Data Type Setting(Fixed-Point Designer).

Programmatic Use

Block Parameter:LockScale

Type:character vector

Values:'off' | 'on'

Default:'off'

State Attributes

The parameters in this tab are primarily of use in code generation.

`State name (e.g., 'position')`— Name for continuous-time filter and integrator states
`”`(default) | character vector

Assign a unique name to the state associated with the integrator or the filter, for continuous-time PID controllers. (For information about state names in a discrete-time PID controller, see theState nameparameter.) The state name is used, for example:

For the corresponding variable in generated code
As part of the storage name when logging states during simulation
For the corresponding state in a linear model obtain by linearizing the block

A valid state name begins with an alphabetic or underscore character, followed by alphanumeric or underscore characters.

Dependencies

To enable this parameter, setTime domaintoContinuous-time.

Programmatic Use

Parameter:IntegratorContinuousStateAttributes,FilterContinuousStateAttributes

Type:character vector

Default:”

`State name`— Names for discrete-time filter and integrator states
empty string (default) | string | character vector

Assign a unique name to the state associated with the integrator or the filter, for discrete-time PID controllers. (For information about state names in a continuous-time PID controller, see theState name (e.g., 'position')parameter.)

A valid state name begins with an alphabetic or underscore character, followed by alphanumeric or underscore characters. The state name is used, for example:

For the corresponding variable in generated code
As part of the storage name when logging states during simulation
For the corresponding state in a linear model obtain by linearizing the block

For more information about the use of state names in code generation, seeApply Storage Classes to Individual Signal, State, and Parameter Data Elements(Simulink Coder).

Dependencies

To enable this parameter, setTime domaintoDiscrete-time.

Programmatic Use

Parameter:IntegratorStateIdentifier,FilterStateIdentifier

Type:string, character vector

Default:""

`State name must resolve to Simulink signal object`— Require that state name resolve to a signal object
`off`(default) |`on`

Select this parameter to require that the discrete-time integrator or filter state name resolves to a Simulink signal object.

Dependencies

To enable this parameter for the discrete-time integrator or filter state:

SetTime domaintoDiscrete-time.
Specify a value for the integrator or filterState name.
Set the model configuration parameterSignal resolutionto a value other thanNone.

Selecting this check box disablesCode generation storage classfor the corresponding integrator or filter state.

Programmatic Use

Block Parameter:IntegratorStateMustResolveToSignalObject,FilterStateMustResolveToSignalObject

Type:string, character vector

Values:"off","on"

Default:"off"

`Code generation storage class`— Storage class for code generation
`Auto`(default) |`ExportedGlobal`|`ImportedExtern`|`ImportedExternPointer`

Select state storage class for code generation. If you do not need to interface to external code, selectAuto.

For more information, seeApply Storage Classes to Individual Signal, State, and Parameter Data Elements(Simulink Coder) andApply Built-In and Customized Storage Classes to Data Elements(Embedded Coder).

Dependencies

To enable this parameter for the discrete-time integrator or filter state:

SetTime domaintoDiscrete-time.
Specify a value for the integrator or filterState name.
Set the model configuration parameterSignal resolutionto a value other thanNone.

Programmatic Use

Block Parameter:IntegratorRTWStateStorageClass,FilterRTWStateStorageClass

Type:string, character vector

Values:"Auto","ExportedGlobal","ImportedExtern"|"ImportedExternPointer"

Default:"Auto"

`Code generation storage type qualifier`— Storage type qualifier
empty string (default) | character vector |`"const"`|`"volatile"`| ...

Specify a storage type qualifier such asconstorvolatile.

Note

This parameter will be removed in a future release. To apply storage type qualifiers to data, use custom storage classes and memory sections. Unless you use an ERT-based code generation target with Embedded Coder^®, custom storage classes and memory sections do not affect the generated code.

Dependencies

To enable this parameter, setCode generation storage classto any value other thanAuto.

Programmatic Use

Block Parameter:IntegratorRTWStateStorageTypeQualifier,FilterRTWStateStorageTypeQualifier

Type:string, character vector

Values:"","const","volatile"

Default:""

Model Examples

Engine Timing Model with Closed Loop Control

Enhance a version of the open-loop engine model (sldemo_engine- described in "Modeling Engine Timing Using Triggered Subsystems" example). This model,sldemo_enginewc,包含一个闭环和显示了灵活性and extensibility of Simulink® models. In this enhanced model, the objective of the controller is to regulate engine speed with a fast throttle actuator, such that changes in load torque have minimal effect. This is easily accomplished in Simulink by adding a discrete-time PI controller to the engine model.

Open Model

Anti-Windup Control Using a PID Controller

Use anti-windup schemes to prevent integration wind-up in PID controllers when the actuators are saturated. We use the PID Controller block in Simulink® which features two built-in anti-windup methods,back-calculationandclamping,以及跟踪模式来处理更多的完整模型x scenarios.

Open Model

Bumpless Control Transfer Between Manual and PID Control

Achieve bumpless control transfer when switching from manual control to PID control. We use the PID Controller block in Simulink® to control a first-order process with dead-time.

Open Model

Block Characteristics

Data Types	`double`\|`fixed point`\|`integer`\|`single`
Direct Feedthrough	`no`
Multidimensional Signals	`no`
Variable-Size Signals	`no`
Zero-Crossing Detection	`no`

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using Simulink® Coder™.

For continuous-time PID controllers (Time domainset toContinuous-time):

Consider usingModel Discretizerto map continuous-time blocks to discrete equivalents that support code generation. To access Model Discretizer, from your model, in theAppstab, underControl Systems, clickModel Discretizer.
Not recommended for production code.

For discrete-time PID controllers (Time domainset toDiscrete-time):

Depends on absolute time when placed inside a triggered subsystem hierarchy.
Generated code relies onmemcpyormemsetfunctions (string.h) under certain conditions.

HDL Code Generation
Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

HDL Coder™ provides additional configuration options that affect HDL implementation and synthesized logic.

HDL Architecture

This block has a single, default HDL architecture.

HDL Block Properties

ConstrainedOutputPipeline	Number of registers to place at the outputs by moving existing delays within your design. Distributed pipelining does not redistribute these registers. The default is`0`. For more details, seeConstrainedOutputPipeline(HDL Coder).
InputPipeline	Number of input pipeline stages to insert in the generated code. Distributed pipelining and constrained output pipelining can move these registers. The default is`0`. For more details, seeInputPipeline(HDL Coder).
OutputPipeline	Number of output pipeline stages to insert in the generated code. Distributed pipelining and constrained output pipelining can move these registers. The default is`0`. For more details, seeOutputPipeline(HDL Coder).

Restrictions

HDL代码生成支持离散金宝appPID controllers only (Time domainset toDiscrete-time).
If theIntegrator methodis set toBackwardEulerorTrapezoidal, you cannot generate HDL code for the block under either of the following conditions:
- Limit output是选取ected and theAnti-Windup Methodis anything other thannone.
- Enable tracking mode是选取ected.
HDL code generation does not support these settings:
- Continuous-time.
- Source>external.
- External reset>rising,falling,either, orlevel.
- Anti-windup方法clampingwhen you use double inputs.

PLC Code Generation
Generate Structured Text code using Simulink® PLC Coder™.

Fixed-Point Conversion
Design and simulate fixed-point systems using Fixed-Point Designer™.

Fixed-point code generation is supported for discrete-time PID controllers only (Time domainset toDiscrete-time).

Discrete PID Controller

Description

Control Configuration

PID Gain Tuning

Ports

Input

Port_1( u )— Error signal inputscalar | vector

P— Proportional gainscalar | vector

Dependencies

I— Integral gainscalar | vector

Dependencies

D— Derivative gainscalar | vector

Dependencies

N— Filter coefficientscalar | vector

Dependencies

Reset- - - - - -克斯特nal reset triggerscalar

Note

Dependencies

I0— Integrator initial conditionscalar | vector

Dependencies

D0— Filter initial conditionscalar | vector

Dependencies

TR— Tracking signalscalar | vector

Dependencies

Output

Port_1( y )— Controller outputscalar | vector

Parameters

Controller——控制器类型PID(default) |PI|PD|P|I

Tip

Programmatic Use

Form— Controller structureParallel(default) |Ideal

Tip

Programmatic Use

Time domain— Specify discrete-time or continuous-time controllerDiscrete-time(default) |Continuous-time

Note

Programmatic Use

Sample time (-1 for inherited)— Discrete interval between samples–1 (default) | positive scalar

Tip

Dependencies

Programmatic Use

Integrator method— Method for computing integral in discrete-time controllerForward Euler(default) |Backward Euler|Trapezoidal

Tip

Note

Dependencies

Programmatic Use

Filter method— Method for computing derivative in discrete-time controllerForward Euler(default) |Backward Euler|Trapezoidal

Tip

Dependencies

Programmatic Use

Main

Source— Source for controller gains and filter coefficientinternal (default) | external

Programmatic Use

Proportional (P)— Proportional gain1 (default) | scalar | vector

Dependencies

Programmatic Use

Integral (I)— Integral gain1 (default) | scalar | vector

Dependencies

Programmatic Use

Derivative (D)— Derivative gain0 (default) | scalar | vector

Dependencies

Programmatic Use

Use filtered derivative— Apply filter to derivative termon(default) |off

Dependencies

Programmatic Use

Filter coefficient (N)— Derivative filter coefficient100 (default) | scalar | vector

Dependencies

Programmatic Use

Select tuning method— Tool for automatic tuning of controller coefficientsTransfer Function Based (PID Tuner App)(default) |Frequency Response Based

Enable zero-crossing detection— Detect zero crossings on reset and on entering or leaving a saturation stateon(default) |off

Programmatic Use

Initialization

Source— Source for integrator and derivative initial conditionsinternal(default) |external

Programmatic Use

Integrator— Integrator initial condition0 (default) | scalar | vector

Dependencies

Programmatic Use

Filter— Filter initial condition0 (default) | scalar | vector

Dependencies

Programmatic Use

Differentiator— Initial condition for unfiltered derivative0 (default) | scalar | vector

`Port_1( u )`— Error signal input
scalar | vector

`P`— Proportional gain
scalar | vector

`I`— Integral gain
scalar | vector

`D`— Derivative gain
scalar | vector

`N`— Filter coefficient
scalar | vector

`Reset`- - - - - -克斯特nal reset trigger
scalar

`I₀`— Integrator initial condition
scalar | vector

`D₀`— Filter initial condition
scalar | vector

`TR`— Tracking signal
scalar | vector

`Port_1( y )`— Controller output
scalar | vector

`Controller`——控制器类型
`PID`(default) |`PI`|`PD`|`P`|`I`

`Form`— Controller structure
`Parallel`(default) |`Ideal`

`Time domain`— Specify discrete-time or continuous-time controller
`Discrete-time`(default) |`Continuous-time`

`Sample time (-1 for inherited)`— Discrete interval between samples
–1 (default) | positive scalar

`Integrator method`— Method for computing integral in discrete-time controller
`Forward Euler`(default) |`Backward Euler`|`Trapezoidal`

`Filter method`— Method for computing derivative in discrete-time controller
`Forward Euler`(default) |`Backward Euler`|`Trapezoidal`

`Source`— Source for controller gains and filter coefficient
internal (default) | external

`Proportional (P)`— Proportional gain
1 (default) | scalar | vector

`Integral (I)`— Integral gain
1 (default) | scalar | vector

`Derivative (D)`— Derivative gain
0 (default) | scalar | vector

`Use filtered derivative`— Apply filter to derivative term
`on`(default) |`off`

`Filter coefficient (N)`— Derivative filter coefficient
100 (default) | scalar | vector

`Select tuning method`— Tool for automatic tuning of controller coefficients
`Transfer Function Based (PID Tuner App)`(default) |`Frequency Response Based`

`Enable zero-crossing detection`— Detect zero crossings on reset and on entering or leaving a saturation state
`on`(default) |`off`

`Source`— Source for integrator and derivative initial conditions
`internal`(default) |`external`

`Integrator`— Integrator initial condition
0 (default) | scalar | vector

`Filter`— Filter initial condition
0 (default) | scalar | vector

`Differentiator`— Initial condition for unfiltered derivative
0 (default) | scalar | vector

`Initial condition setting`— Location at which initial condition is applied
`State (most efficient)`(default) |`Output`

`External reset`— Trigger for resetting integrator and filter values
`none`(default) |`rising`|`falling`|`either`|`level`

`Ignore reset when linearizing`— Force linearization to ignore reset
`off`(default) |`on`

`Enable tracking mode`— Activate signal tracking
`off`(default) |`on`

`Tracking coefficient (Kt)`— Gain of signal-tracking feedback loop
1 (default) | scalar

`Limit Output`— Limit block output to specified saturation values
`off`(default) |`on`

`Upper limit`— Upper saturation limit for block output
`Inf`(default) | scalar

`Lower limit`— Lower saturation limit for block output
`-Inf`(default) | scalar

`Ignore saturation when linearizing`— Force linearization to ignore output limits
`off`(default) |`on`

`Anti-windup方法`— Integrator anti-windup method
`none`(default) |`back-calculation`|`clamping`

`Back-calculation coefficient (Kb)`— Gain coefficient of anti-windup feedback loop
1 (default) | scalar

`Integer rounding mode`— Rounding mode for fixed-point operations
`Floor`(default) |`Ceiling`|`Convergent`|`Nearest`|`Round`|`Simplest`|`Zero`

`Saturate on integer overflow`— Method of overflow action
`off`(default) |`on`

`Lock data type settings against changes by the fixed-point tools`— Prevent fixed-point tools from overriding data types
`off`(default) |`on`

`State name (e.g., 'position')`— Name for continuous-time filter and integrator states
`”`(default) | character vector

`State name`— Names for discrete-time filter and integrator states
empty string (default) | string | character vector

`State name must resolve to Simulink signal object`— Require that state name resolve to a signal object
`off`(default) |`on`

`Code generation storage class`— Storage class for code generation
`Auto`(default) |`ExportedGlobal`|`ImportedExtern`|`ImportedExternPointer`

`Code generation storage type qualifier`— Storage type qualifier
empty string (default) | character vector |`"const"`|`"volatile"`| ...

C/C++ Code Generation
Generate C and C++ code using Simulink® Coder™.

HDL Code Generation
Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.