Integrate input signal twice

Continuous

The Second-Order Integrator block and the Second-Order Integrator Limited block solve the second-order initial value problem:

$\begin{array}{l}\frac{{d}^{2}x}{d{t}^{2}}=u,\\ {\frac{dx}{dt}|}_{t=0}=d{x}_{o},\\ {x|}_{t=0}={x}_{o},\end{array}$

where *u* is the input to the system. The block
is therefore a dynamic system with two continuous states: *x* and *dx/dt*.

These two states have a mathematical relationship, namely, that *dx/dt* is
the derivative of *x*. In order to satisfy this relationship
throughout the simulation, Simulink places various constraints on
the block parameters and behavior.

The Second-Order Integrator Limited block is identical to the Second-Order Integrator block with the exception that it defaults to limiting the states based on the specified upper and lower limits. For more information, see Limiting the States.

Simulink^{®} software can use a number of different numerical
integration methods to compute the outputs of the block. Each has
advantages for specific applications. Use the **Solver** pane
of the Configuration Parameters dialog box to select the technique
best suited to your application. (For more information, see About Solvers.)
The selected solver computes the states of the Second-Order
Integrator block at the current time step using the current
input value.

Use the block parameter dialog box to:

Specify whether the source of each state initial condition is internal or external

Specify a value for the state initial conditions

Define upper and lower limits on either or both states

Specify absolute tolerances for each state

Specify names for both states

Choose an external reset condition

Enable zero-crossing detection

Reinitialize dx/dt when x reaches saturation

Specify that Simulink disregard the state limits and external reset for linearization operations

You can define the initial conditions of each state individually as a parameter on the block dialog box or input one or both of them from an external signal.

To define the initial conditions of state

*x*as a block parameter, use the**Initial condition source x**drop-down menu to select`internal`

and enter the value in the**Initial condition x**field.To provide the initial conditions from an external source for state

*x*, specify the**Initial condition source x**parameter as`external`

. An additional input port appears on the block.To define the initial conditions of state

*dx/dt*as a block parameter, use the**Initial condition source dx/dt**drop-down menu to select`internal`

and enter the value in the**Initial condition dx/dt**field.To provide the initial conditions from an external source for state

*dx/dt*, specify**Initial condition source dx/dt**as`external`

. An additional input port appears on the block.

If you choose to use an external source for both state initial conditions, your block appears as follows.

Simulink does not allow initial condition values of

`inf`

or`NaN`

.If you limit state

*x*or state*dx/dt*by specifying saturation limits (see Limiting the States) and one or more initial conditions are outside the corresponding limits, then the respective states are initialized to the closest valid value and a set of consistent initial conditions is calculated.

When
modeling a second-order system, you may need to limit the block states.
For example, the motion of a piston within a cylinder is governed
by Newton's Second Law and has constraints on the piston position
(*x*). With the Second-Order Integrator block,
you can limit the states *x* and *dx/dt* independent
of each other. You can even change the limits during simulation; however,
you cannot change whether or not the states are limited. An important
rule to follow is that an upper limit must be strictly greater than
its corresponding lower limit.

The block appearance changes when you limit one or both states. Shown below is the appearance of the block with both states limited.

For each state, you can use the block parameter dialog box to set appropriate saturation limits.

If you use the Second-Order Integrator Limited block,
both states are limited by default. But you can also manually limit
state *x* on the Second-Order Integrator block
by selecting **Limit x ** and entering the limits
in the appropriate parameter fields.

The block then determines the values of the states as follows:

When

*x*is less than or equal to its lower limit, the value of*x*is held at its lower limit and*dx/dt*is set to zero.When

*x*is in between its lower and upper limits, both states follow the trajectory given by the second-order ODE.When

*x*is greater than or equal to its upper limit, the value of*x*is held at its upper limit and*dx/dt*is set to zero.

You can choose to reinitialize *dx/dt* to a
new value at the time when *x* reaches saturation.
See Reinitializing dx/dt when x reaches saturation

As with state *x*, state *dx/dt* is
set as limited by default on the **dx/dt** pane of
the Second-Order Integrator Limited parameter dialog box. You can
manually set this parameter, **Limit dx/dt**, on
the Second-Order Integrator block. In either case, you must enter
the appropriate limits for *dx/dt*.

If you limit only the state *dx/dt*, then the
block determines the values of *dx/dt* as follows:

When

*dx/dt*is less than or equal to its lower limit, the value of*dx/dt*is held at its lower limit.When

*dx/dt*is in between its lower and upper limits, both states follow the trajectory given by the second-order ODE.When

*dx/dt*is greater than or equal to its upper limit, the value of*dx/dt*is held at its upper limit.

When state *dx/dt* is held at it upper or lower
limit, the value of *x* is governed by the first-order
initial value problem:

$$\begin{array}{l}\frac{dx}{dt}=L,\\ x({t}_{L})={x}_{L,}\end{array}$$

where *L* is the *dx/dt* limit
(upper or lower), *t*_{L} is
the time when *dx/dt* reaches this limit, and *x*_{L} is
the value of state *x * at that time.

When you limit both states, Simulink maintains mathematical
consistency of the states by limiting the allowable values of the
upper and lower limits for *dx/dt*. Such limitations
are necessary to satisfy the following constraints:

When

*x*is at its saturation limits, the value of*dx/dt*must be zero.In order for

*x*to leave the upper limit, the value of*dx/dt*must be strictly negative.In order for

*x*to leave its lower limit, the value of*dx/dt*must be strictly positive.

Consequently, for such cases, the upper limit of *dx/dt* must
be strictly positive and the lower limit of *dx/dt* must
be strictly negative.

When both states are limited, the block determines the states as follows:

Whenever

*x*reaches its limits, the resulting behavior is the same as that described in “Limiting x only”.Whenever

*dx/dt*reaches one of its limits, the resulting behavior is the same as that described in “Limiting dx/dt only” — including the computation of*x*using a first-order ODE when*dx/dt*is held at one of its limits. In such cases, when*x*reaches one of its limits, it is held at that limit and*dx/dt*is set to zero.Whenever both reach their respective limits simultaneously, the state

*x*behavior overrides*dx/dt*behavior to maintain consistency of the states.

When you limit both states, you can choose to reinitialize *dx/dt* at
the time when state *x* reaches saturation. If the
reinitialized value is outside specified limits on *dx/dt*,
then *dx/dt* is reinitialized to the closest valid
value and a consistent set of initial conditions is calculated. See Reinitializing dx/dt when x reaches saturation

The block can reset its states to the specified initial
conditions based on an external signal. To cause the block to reset
its states, select one of the **External reset** choices
on the **Attributes** pane. A trigger port appears
on the block below its input port and indicates the trigger type.

Select

`rising`

to reset the states when the reset signal rises from zero to a positive value, from a negative to a positive value, or a negative value to zero.Select

`falling`

to reset the states when the reset signal falls from a positive value to zero, from a positive to a negative value, or from zero to negative.Select

`either`

to reset the states when the reset signal changes from zero to a nonzero value or changes sign.

The reset port has direct feedthrough. If the block output feeds back into this port, either directly or through a series of blocks with direct feedthrough, an algebraic loop results (see Algebraic Loops).

This parameter controls whether zero-crossing detection is enabled
for this block. By default, the **Enable zero-crossing detection **parameter
is selected on the **Attributes **pane. However,
this parameter is only in affect if the **Zero-crossing control**,
on the **Solver ** pane of the Configuration Parameters
dialog, is set to `Use local settings`

. For
more information, see Zero-Crossing Detection.

For certain modeling applications, *dx/dt* must
be reinitialized when state *x* reaches its limits
in order to pull *x* out of saturation immediately.
You can achieve this by selecting **Reinitialize dx/dt when
x reaches saturation** on the **Attributes** pane.

If this option is on, then at the instant when *x * reaches
saturation, Simulink checks whether the current value of the *dx/dt* initial
condition (parameter or signal) allows the state *x* to
leave saturation immediately. If so, Simulink reinitializes state *dx/dt* with
the value of the initial condition (parameter or signal) at that instant.
If not, Simulink ignores this parameter at the current instant and
sets *dx/dt* to zero to make the block states consistent.

This parameter only applies at the time when *x* actually
reaches saturation limit. It does not apply at any future time when *x* is
being held at saturation.

Refer to the sections on limiting the states for more information.
For an example, see the `sldemo_bounce`

example.

For cases where you simplify your model by linearizing it, you
can have Simulink disregard the limits of the states and the
external reset by selecting **Ignore state limits and the
reset for linearization**.

By
default Simulink software uses the absolute tolerance value specified
in the Configuration Parameters dialog box (see Error Tolerances for Variable-Step Solvers)
to compute the output of the integrator blocks. If this value does
not provide sufficient error control, specify a more appropriate value
for state *x* in the **Absolute tolerance
x** field and for state *dx/dt* in the **Absolute
tolerance dx/dt** field of the parameter dialog box. Simulink uses
the values that you specify to compute the state values of the block.

You can control whether or not to display the *x* or
the *dx/dt* output port using the `ShowOutput`

parameter.
You can display one output port or both; however, you must select
at least one.

You can specify the name of *x* states and *dx/dt* states
using the `StateNameX`

and `StateNameDXDT`

parameters.
However, you must specify names for either both or neither; you cannot
specify names for just *x * or just *dx/dt*.
Both state names must have identical type and length. Furthermore,
the number of names must evenly divide the number of states.

When you select all options, the block icon looks like this.

The Integrator block accepts and outputs signals of type `double`

on
its data ports. The external reset port accepts signals of type `double`

or `Boolean`

.

For more information, see Data Types Supported by Simulink in the Simulink documentation.

Specify the initial condition source for state x.

**Default:** `internal`

`internal`

Get the initial conditions of state

*x*from the**Initial condition x**parameter.`external`

Get the initial conditions of state

*x*from an external block.

Simulink software does not allow the initial condition of this
block to be `inf`

or `NaN`

.

Selecting `internal`

enables the ** Initial
condition x** parameter.

Selecting `external`

disables the ** Initial
condition x** parameter..

Parameter: `ICSourceX` |

Type: character vector |

Value: `'internal'` | `'external'` |

Default: `'internal'` |

Specify the initial condition of state *x*.

**Default:** 0.0

Simulink software does not allow the initial condition of this
block to be` inf`

or `NaN`

.

Setting **Initial condition source x** to `internal`

enables
this parameter.

Setting** Initial condition source x** to `external`

disables
this parameter.

Parameter: ` ICX` |

Type: scalar or vector |

Value: ` '0'` |

Default: ` '0'` |

Limit state *x* of the block to a value between
the **Lower limit x** and **Upper limit x** parameters.

**Default:** `Off`

for
Second-Order Integrator, `On`

for Second-Order Integrator
Limited

- On
Limit state

*x*to a value between the**Lower limit x**and**Upper limit x**parameters.- Off
Do not limit the state x output to a value between the

**Lower limit x**and**Upper limit x**parameters.

This parameter enables **Upper limit x** parameter.

This parameter enables **Lower limit x** parameter.

Parameter: ` LimitX` |

Type: character vector |

Value: `'off'` | `'on'` |

Default: `'off'` |

Specify the upper limit of state* x*.

**Default:** ` inf`

for
Second-Order Integrator, `1`

for Second-Order Integrator
Limited

The upper saturation limit for state *x* must
be strictly greater than the lower saturation limit.

**Limit x** enables this parameter.

Parameter: ` UpperLimitX` |

Type: scalar or vector |

Value: ` 'inf'` |

Default: `'inf'` |

Specify the lower limit of state *x*.

**Default:** ` –inf`

for
Second-Order Integrator, `0`

for Second-Order Integrator
Limited

The lower saturation limit for state *x* must
be strictly less than the upper saturation limit.

**Limit x** enables this parameter.

Parameter: `LowerLimitX` |

Type: scalar or vector |

Value: `'-inf'` |

Default: `'-inf'` |

Enable wrapping of *x* between the **Wrapped
upper value x** and **Wrapped lower value x** parameters.
Enabling wrapping of *x* eliminates the need for
zero-crossing detection, reduces solver resets, improves solver performance
and accuracy, and increases simulation time span when modeling rotary
and cyclic state trajectories.

**Default:** `off`

- On
Enable wrapping of

*x*between the**Wrapped upper value x**and**Wrapped lower value x**parameters.If you specify

**Wrapped upper value x**as`inf`

and**Wrapped lower value x**as`-inf`

, wrapping will never occur.- Off
Do not enable wrapping of

*x*.

This parameter enables **Wrapped upper value x**.

This parameter enables **Wrapped lower value x**.

Parameter: `WrapX` |

Type: character vector |

Value: `'off'` | `'on'` |

Default: `'off'` |

Specify the upper value for wrapping *x*.

**Default:** `'pi'`

**Wrap x** enables this parameter.

Parameter: `WrappedUpperValueX` |

Type: scalar or vector |

Value: `'2*pi'` |

Default: `'pi'` |

Specify the lower value for wrapping *x*.

**Default:** `-pi`

**Wrap x** enables this parameter.

Parameter: `WrappedLowerValueX` |

Type: scalar or vector |

Value: `'0'` |

Default: `'-pi'` |

Specify the absolute tolerance for computing state *x*.

**Default:** auto

You can enter

`auto`

, –1, a positive real scalar or vector.If you enter

`auto`

or –1, Simulink uses the absolute tolerance value in the Configuration Parameters dialog box (see Solver Pane) to compute state*x*.If you enter a real scalar value, that value overrides the absolute tolerance in the Configuration Parameters dialog box and is used for computing all

*x*states.If you enter a real vector, the dimension of that vector must match the dimension of state

*x*. These values override the absolute tolerance in the Configuration Parameters dialog box.

Parameter: ` AbsoluteToleranceX` |

Type: character vector,
scalar, or vector |

Value: `'auto'` | `'-1'` |
any positive real scalar or vector |

Default: `'auto'` |

Assign a unique name to state *x*.

**Default:**` ''`

To assign a name to a single state, enter the name between quotes, for example, position'.

To assign names to multiple

*x*states, enter a comma-delimited list surrounded by braces, for example, {'a', 'b', 'c'}. Each name must be unique.The state names apply only to the selected block.

If you specify a state name for

*x*, you must also specify a state name for*dx/dt*.State names for

*x*and*dx/dt*must have identical types and lengths.The number of states must be evenly divided by the number of state names. You can specify fewer names than

*x*states, but you cannot specify more names than*x*states. For example, you can specify two names in a system with four states. The first name applies to the first two states and the second name to the last two states. However, you must be consistent and apply the same scheme to the state names for*dx/dt*.To assign state names with a variable in the MATLAB

^{®}workspace, enter the variable without quotes. A variable can be a character vector or a cell array.

Parameter: ` StateNameX` |

Type: character vector |

Value: `' '` |
user-defined |

Default: `' '` |

Specify the initial condition source for state *dx/dt*.

**Default:** `internal`

`internal`

Get the initial conditions of state

*dx/dt*from the**Initial condition dx/dt**parameter.`external`

Get the initial conditions of state

*dx/dt*from an external block.

Simulink software does not allow the initial condition of this
block to be` inf`

or `NaN`

.

Selecting` internal`

enables the** Initial
condition dx/dt** parameter.

Selecting `external`

disables the **Initial
condition dx/dt** parameter.

Parameter: ` ICSourceDXDT` |

Type: character vector |

Value: `'internal'` | `'external'` |

Default: `'internal'` |

Specify the initial condition of state *dx/dt*.

**Default:** 0.0

Simulink software does not allow the initial condition of this
block to be `inf`

or `NaN`

.

Setting **Initial condition source dx/dt ** to `internal`

enables
this parameter.

Setting** Initial condition source dx/dt** to `external`

disables
this parameter.

Parameter: ` ICDXDT` |

Type: scalar or vector |

Value: ` '0'` |

Default: ` '0'` |

Limit the dx/dt state of the block to a value between the **Lower
limit dx/dt** and **Upper limit dx/dt** parameters.

**Default:** `Off`

for
Second-Order Integrator, `On`

for Second-Order Integrator
Limited

- On
Limit state

*dx/dt*of the block to a value between the**Lower limit dx/dt**and**Upper limit dx/dt**parameters.- Off
Do not limit state

*dx/dt*of the block to a value between the**Lower limit dx/dt**and**Upper limit dx/dt**parameters.

If you set saturation limits for *x*, then
the interval defined by the **Upper limit dx/dt** and **Lower
limit dx/dt** must contain zero.

This parameter enables **Upper limit dx/dt**.

This parameter enables **Lower limit dx/dt**.

Parameter: ` LimitDXDT` |

Type: character vector |

Value: `'Off'` | `'On'` |

Default: `'Off'` |

Specify the upper limit for state *dx/dt*.

**Default:** `'inf'`

If you limit* x*, then this parameter must
have a strictly positive value.

**Limit dx/dt ** enables this parameter.

Parameter: ` UpperLimitDXDT` |

Type: scalar or vector |

Value: `'inf'` |

Default: `'inf'` |

Specify the lower limit for state *dx/dt*.

**Default:**` '-inf'`

If you limit *x*, then this parameter must
have a strictly negative value.

**Limit dx/dt ** enables this parameter.

Parameter: ` LowerLimitDXDT` |

Type: scalar or vector |

Value: `'-inf'` |

Default: `'-inf'` |

Specify the absolute tolerance for computing state *dx/dt*.

**Default:**` auto`

You can enter

`auto`

, –1, a positive real scalar or vector.If you enter

`auto`

or –1, then Simulink uses the absolute tolerance value in the Configuration Parameters dialog box (see Solver Pane) to compute the*dx/dt*output of the block.If you enter a numeric value, that value overrides the absolute tolerance in the Configuration Parameters dialog box.

Parameter: ` AbsoluteToleranceDXDT` |

Type: character vector,
scalar, or vector |

Value: `'auto'` | `'-1'` |
any positive real scalar or vector |

Default: `'auto'` |

Assign a unique name to state *dx/dt*.

**Default:**` ''`

To assign a name to a single state, enter the name between quotes, for example, 'velocity'.

To assign names to multiple

*dx/dt*states, enter a comma-delimited list surrounded by braces, for example, {'a', 'b', 'c'}. Each name must be unique.The state names apply only to the selected block.

If you specify a state name for

*dx/dt*, you must also specify a state name for*x*.State names for

*x*and*dx/dt*must have identical types and lengths.The number of states must be evenly divided by the number of state names. You can specify fewer names than

*dx/dt*states, but you cannot specify more names than*dx/dt*states. For example, you can specify two names in a system with four states. The first name applies to the first two states and the second name to the last two states. However, you must be consistent and apply the same scheme to the state names for*x*.To assign state names with a variable in the MATLAB workspace, enter the variable without quotes. A variable can be a character vector or a cell array.

Parameter: ` StateNameDXDT` |

Type: character vector |

Value: ` ' '` |
user-defined |

Default: ` ' '` |

Reset the states to their initial conditions when a trigger event occurs in the reset signal.

**Default:** `none`

`none`

Do not reset the state to initial conditions.

`rising`

Reset the state when the reset signal rises from a zero to a positive value or from a negative to a positive value.

`falling`

Reset the state when the reset signal falls from a positive value to zero or from a positive to a negative value.

`either`

Reset the state when the reset signal changes from zero to a nonzero value or changes sign.

Parameter: ` ExternalReset` |

Type: character vector |

Value: `'none'` | `'rising'` | `'falling'` | `'either'` |

Default: `'none'` |

Select to enable zero-crossing detection. For more information, see Zero-Crossing Detection.

**Default:** On

- On
Enable zero-crossing detection.

- Off
Do not enable zero-crossing detection.

Parameter: `ZeroCross` |

Type: character vector |

Value: `'on'` | `'off'` |

Default: `'on'` |

At the instant when state *x* reaches saturation,
reset *dx/dt* to its current initial conditions.

**Default:** Off

- On
Reset

*dx/dt*to its initial conditions when*x*becomes saturated.- Off
Do not reset

*dx/dt*to its initial conditions when*x*becomes saturated.

The *dx/dt * initial condition must have a
value that enables *x* to leave saturation immediately.
Otherwise, Simulink ignores the initial conditions for *dx/dt* to
preserve mathematical consistency of block states.

Parameter: ` ReinitDXDTwhenXreachesSaturation` |

Type: character vector |

Value: `'off'` | `'on'` |

Default: `'off'` |

For linearization purposes, have Simulink ignore the specified state limits and the external reset.

**Default:** Off

- On
Ignore the specified state limits and the external reset.

- Off
Apply the specified state limits and the external reset setting.

Parameter: ` IgnoreStateLimitsAndResetForLinearization` |

Type: character vector |

Value: `'off'` | `'on'` |

Default: `'off'` |

Specify the output ports on the block.

**Default:** `both`

`both`

Show both

*x*and*dx/dt*output ports.`x`

Show only the

*x*output port.`dx/dt`

Show only the

*dx/dt*output port.

Parameter: ` ShowOutput` |

Type: character vector |

Value: `'both'` | `'x'` | `'dxdt'` |

Default: `'both'` |

Data Types | Double |

Multidimensional Signals | No |

Variable-Size Signals | No |

Code Generation | Yes |

Was this topic helpful?