This is the text-book version of a PID-controller.
For a more practically useful PID-controller, use
block LimPID.

The PID block can be initialized in different
ways controlled by parameter **initType**. The possible
values of initType are defined in
Modelica.Blocks.Types.InitPID.
This type is identical to
Types.Init,
with the only exception that the additional option
**DoNotUse_InitialIntegratorState** is added for
backward compatibility reasons (= integrator is initialized with
InitialState whereas differential part is initialized with
NoInit which was the initialization in version 2.2 of the Modelica
standard library).

Based on the setting of initType, the integrator (I) and derivative (D)
blocks inside the PID controller are initialized according to the following table:

**initType** |
**I.initType** |
**D.initType** |

**NoInit** |
NoInit |
NoInit |

**SteadyState** |
SteadyState |
SteadyState |

**InitialState** |
InitialState |
InitialState |

**InitialOutput**
and initial equation: y = y_start |
NoInit |
SteadyState |

**DoNotUse_InitialIntegratorState** |
InitialState |
NoInit |

In many cases, the most useful initial condition is
**SteadyState** because initial transients are then no longer
present. If initType = InitPID.SteadyState, then in some
cases difficulties might occur. The reason is the
equation of the integrator:

**der**(y) = k*u;

The steady state equation "der(x)=0" leads to the condition that the input u to the
integrator is zero. If the input u is already (directly or indirectly) defined
by another initial condition, then the initialization problem is **singular**
(has none or infinitely many solutions). This situation occurs often
for mechanical systems, where, e.g., u = desiredSpeed - measuredSpeed and
since speed is both a state and a derivative, it is natural to
initialize it with zero. As sketched this is, however, not possible.
The solution is to not initialize u or the variable that is used
to compute u by an algebraic equation.