LIBRARY

`Continuous.LimPID`

PID controller with limited output, back calculation anti-windup compensation, setpoint weighting and feed-forward

The transfer function is:

The integral and derivative parts can be removed structurally with the with_I and with_D parameters, turning the controller into a P, PI, or PD controller. A structurally removed part contributes no state variables, unlike, e.g., setting Td = 0, which would leave the derivative filter in place with a vanishingly small time constant and cause extreme stiffness.

This component extends from BlockComponents.Interfaces.SingleVariableController

Usage

BlockComponents.Continuous.LimPID(k=1, Ti=0.5, Td=0.1, y_max=1e300, y_min=-y_max, wp=1, wd=1, Ni=0.9, Nd=10, k_ff=1, xi0=0, xd0=0)

Parameters:

Name	Description	Units	Default value
`with_I`	Whether or not to include the integral part	–	true
`with_D`	Whether or not to include the derivative part	–	true
`k`	Gain of controller	–	1
`Ti`	Time constant of the integrator block (only active if `with_I = true`)	s	0.5
`Td`	Time constant of the derivative block (only active if `with_D = true`)	s	0.1
`y_max`	Maximum output	–	1e300
`y_min`	Minimum output	–	-y_max
`wp`	Set-point weight for proportional block	–	1
`wd`	Set-point weight for derivative block (only active if `with_D = true`)	–	1
`Ni`	`Ni*Ti` is time constant of anti-windup compensation (only active if `with_I = true`)	–	0.9
`Nd`	Maximum derivative gain. Higher the value of `Nd`, the more ideal the derivative block gets (less filtering, higher high-frequency gain). (only active if `with_D = true`)	–	10
`k_ff`	Gain of the feed-forward input	–	1
`xi0`	Initial guess value for integrator output (only active if `with_I = true`)	–	0
`xd0`	Initial guess value for derivative output (only active if `with_D = true`)	–	0

Connectors

u_s - This connector represents a real signal as an input to a component (RealInput)
u_m - This connector represents a real signal as an input to a component (RealInput)
y - This connector represents a real signal as an output from a component (RealOutput)
u_ff - This connector represents a real signal as an input to a component (RealInput)

Variables

Name	Description	Units
`control_error`		–

Behavior

Source

dyad

"""
PID controller with limited output, back calculation anti-windup compensation, setpoint weighting and feed-forward

The transfer function is:

```math
y = k \left[e + \dfrac{1}{T_is}\left(e + \dfrac{y_{sat} - y}{N_iT_i}\right)  + \dfrac{T_ds}{1 + {\dfrac{T_d}{N_d}s}}e \right] + k_{ff}u_{ff}
```

The integral and derivative parts can be removed structurally with the `with_I`
and `with_D` parameters, turning the controller into a P, PI, or PD controller.
A structurally removed part contributes no state variables, unlike, e.g.,
setting `Td = 0`, which would leave the derivative filter in place with a
vanishingly small time constant and cause extreme stiffness.
"""
component LimPID
  extends BlockComponents.Interfaces.SingleVariableController
  u_ff = RealInput() {
    "Dyad": {
      "placement": {
        "diagram": {"iconName": "input", "x1": 450, "y1": -100, "x2": 550, "y2": 0, "rot": 90}
      },
      "tags": []
    }
  }
  add_p = BlockComponents.Math.Add(final k1 = wp, final k2 = -1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 100, "y1": 100, "x2": 200, "y2": 200, "rot": 0},
        "diagram": {"iconName": "input", "x1": 100, "y1": 90, "x2": 200, "y2": 190, "rot": 0}
      },
      "tags": []
    }
  }
  add_d = BlockComponents.Math.Add(final k1 = wd, final k2 = -1) if with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 100, "y1": 300, "x2": 200, "y2": 400}}
    }
  }
  add_i = BlockComponents.Math.Add3(final k1 = 1, final k2 = -1, final k3 = 1) if with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 100, "y1": 500, "x2": 200, "y2": 600}}
    }
  }
  proportional = BlockComponents.Math.Gain(final k = 1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 300, "y1": 100, "x2": 400, "y2": 200, "rot": 0},
        "diagram": {"iconName": "input", "x1": 300, "y1": 90, "x2": 400, "y2": 190, "rot": 0}
      },
      "tags": []
    }
  }
  derivative = Derivative(final k = Td, final T = max(Td / Nd, 1e-14), final x0 = xd0) if with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 300, "x2": 400, "y2": 400}}
    }
  }
  integrator = Integrator(final k = 1 / Ti, final x0 = xi0) if with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 500, "x2": 400, "y2": 600}}
    }
  }
  "Zero contribution of the structurally removed derivative part"
  zero_d = BlockComponents.Sources.Constant(final k = 0) if !with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 300, "x2": 400, "y2": 400}}
    }
  }
  "Zero contribution of the structurally removed integral part"
  zero_i = BlockComponents.Sources.Constant(final k = 0) if !with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 500, "x2": 400, "y2": 600}}
    }
  }
  add_pid = BlockComponents.Math.Add3(final k1 = 1, final k2 = 1, final k3 = 1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 500, "y1": 300, "x2": 600, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 500, "y1": 120, "x2": 600, "y2": 220, "rot": 0}
      },
      "tags": []
    }
  }
  gain_pid = BlockComponents.Math.Gain(final k = k) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 700, "y1": 300, "x2": 800, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 550, "y1": 310, "x2": 650, "y2": 410, "rot": 0}
      },
      "tags": []
    }
  }
  add_ff = BlockComponents.Math.Add(final k1 = 1, final k2 = k_ff) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 900, "y1": 300, "x2": 1000, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 710, "y1": 340, "x2": 810, "y2": 440, "rot": 0}
      },
      "tags": []
    }
  }
  #    NOTE: using final for these parameters causes a bug.  
  #          see https://github.com/JuliaComputing/dyad-lang/issues/1640
  limiter = BlockComponents.Nonlinear.Limiter(y_max = y_max, y_min = y_min) {
    "Dyad": {"placement": {"diagram": {"x1": 870, "x2": 970, "y1": 450, "y2": 550}}}
  }
  add_sat = BlockComponents.Math.Add(final k1 = 1, final k2 = -1) if with_I {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 1100, "y1": 500, "x2": 1200, "y2": 600, "rot": 90},
        "diagram": {"iconName": "input", "x1": 800, "y1": 590, "x2": 900, "y2": 690, "rot": 90}
      },
      "tags": []
    }
  }
  gain_track = BlockComponents.Math.Gain(final k = 1 / (k * Ni)) if with_I {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 500, "y1": 700, "x2": 600, "y2": 800, "rot": 180}
      }
    }
  }
  variable control_error::Real
  "Whether or not to include the integral part"
  structural parameter with_I::Boolean = true
  "Whether or not to include the derivative part"
  structural parameter with_D::Boolean = true
  "Gain of controller"
  parameter k::Real = 1
  "Time constant of the integrator block (only active if `with_I = true`)"
  parameter Ti::Time = 0.5
  "Time constant of the derivative block (only active if `with_D = true`)"
  parameter Td::Time = 0.1
  "Maximum output"
  parameter y_max::Real = 1e300
  "Minimum output"
  parameter y_min::Real = -y_max
  "Set-point weight for proportional block"
  parameter wp::Real = 1
  "Set-point weight for derivative block (only active if `with_D = true`)"
  parameter wd::Real = 1
  "`Ni*Ti` is time constant of anti-windup compensation (only active if `with_I = true`)"
  parameter Ni::Real = 0.9
  "Maximum derivative gain. Higher the value of `Nd`, the more ideal the derivative block gets (less filtering, higher high-frequency gain). (only active if `with_D = true`)"
  parameter Nd::Real = 10
  "Gain of the feed-forward input"
  parameter k_ff::Real = 1
  "Initial guess value for integrator output (only active if `with_I = true`)"
  parameter xi0::Real = 0
  "Initial guess value for derivative output (only active if `with_D = true`)"
  parameter xd0::Real = 0
relations
  connect(add_p.y, proportional.u) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(proportional.y, add_pid.u1) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(add_pid.y, gain_pid.u) {
    "Dyad": {
      "edges": [
        {
          "S": 1,
          "M": [
            {"x": 650, "y": 170},
            {"x": 650, "y": 260},
            {"x": 510, "y": 260},
            {"x": 510, "y": 360}
          ],
          "E": 2
        }
      ],
      "renderStyle": "standard"
    }
  }
  connect(gain_pid.y, add_ff.u1) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(add_ff.y, limiter.u) {
    "Dyad": {"edges": [{"S": 1, "M": [{"x": 840, "y": 390}, {"x": 840, "y": 500}], "E": 2}]}
  }
  control_error = u_s - u_m
  connect(limiter.y, y) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}]}}
  connect(add_ff.u2, u_ff) {
    "Dyad": {
      "edges": [
        {
          "S": 1,
          "M": [{"x": 670, "y": 420}, {"x": 670, "y": 80}, {"x": 500, "y": 80}],
          "E": 2
        }
      ],
      "renderStyle": "standard"
    }
  }
  connect(add_p.u1, u_s) {
    "Dyad": {
      "edges": [{"S": 1, "M": [{"x": 20, "y": 110}, {"x": 20, "y": 270}], "E": 2}],
      "renderStyle": "standard"
    }
  }
  connect(u_m, add_p.u2) {
    "Dyad": {
      "edges": [{"S": 1, "M": [{"x": 50, "y": 730}, {"x": 50, "y": 170}], "E": 2}],
      "renderStyle": "standard"
    }
  }
  if with_D
    connect(add_d.y, derivative.u) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(derivative.y, add_pid.u2) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 452.5, "y": 350}, {"x": 452.5, "y": 170}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_d.u1, u_s) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 20, "y": 320}, {"x": 20, "y": 270}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_d.u2, u_m) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 50, "y": 380}, {"x": 50, "y": 730}], "E": 2}],
        "renderStyle": "standard"
      }
    }
  else
    connect(zero_d.y, add_pid.u2) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
  end
  if with_I
    connect(add_i.y, integrator.u) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(integrator.y, add_pid.u3) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 490, "y": 550}, {"x": 490, "y": 200}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(limiter.y, add_sat.u1) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(add_sat.y, gain_track.u) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 850, "y": 750}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(gain_track.y, add_i.u3) {
      "Dyad": {"edges": [{"S": 1, "M": [{"x": 75, "y": 750}, {"x": 75, "y": 580}], "E": 2}]}
    }
    connect(add_i.u1, u_s) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 20, "y": 520}, {"x": 20, "y": 270}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_i.u2, u_m) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 50, "y": 550}, {"x": 50, "y": 730}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_ff.y, add_sat.u2) {
      "Dyad": {
        "edges": [
          {
            "S": 1,
            "M": [{"x": 830, "y": 390}, {"x": 830, "y": 545}, {"x": 820, "y": 545}],
            "E": 2
          }
        ],
        "renderStyle": "standard"
      }
    }
  else
    connect(zero_i.y, add_pid.u3) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
  end
metadata {
  "Dyad": {
    "labels": [{"label": "$(instance)", "x": 500, "y": 1100, "rot": 0}],
    "icons": {"default": "dyad://BlockComponents/LimPID.svg"}
  }
}
end

Flattened Source

dyad

"""
PID controller with limited output, back calculation anti-windup compensation, setpoint weighting and feed-forward

The transfer function is:

```math
y = k \left[e + \dfrac{1}{T_is}\left(e + \dfrac{y_{sat} - y}{N_iT_i}\right)  + \dfrac{T_ds}{1 + {\dfrac{T_d}{N_d}s}}e \right] + k_{ff}u_{ff}
```

The integral and derivative parts can be removed structurally with the `with_I`
and `with_D` parameters, turning the controller into a P, PI, or PD controller.
A structurally removed part contributes no state variables, unlike, e.g.,
setting `Td = 0`, which would leave the derivative filter in place with a
vanishingly small time constant and cause extreme stiffness.
"""
component LimPID
  "Connector of setpoint input signal"
  u_s = RealInput() {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "default", "x1": -100, "y1": 220, "x2": 0, "y2": 320, "rot": 0},
        "diagram": {"iconName": "default", "x1": -100, "y1": 220, "x2": 0, "y2": 320, "rot": 0}
      }
    }
  }
  "Connector of measurement input signal"
  u_m = RealInput() {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "default", "x1": -100, "y1": 680, "x2": 0, "y2": 780, "rot": 0},
        "diagram": {"iconName": "default", "x1": -100, "y1": 680, "x2": 0, "y2": 780, "rot": 0}
      }
    }
  }
  "Connector of actuator output signal"
  y = RealOutput() {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "output", "x1": 1000, "y1": 450, "x2": 1100, "y2": 550, "rot": 0},
        "diagram": {"iconName": "output", "x1": 1000, "y1": 450, "x2": 1100, "y2": 550, "rot": 0}
      }
    }
  }
  u_ff = RealInput() {
    "Dyad": {
      "placement": {
        "diagram": {"iconName": "input", "x1": 450, "y1": -100, "x2": 550, "y2": 0, "rot": 90}
      },
      "tags": []
    }
  }
  add_p = BlockComponents.Math.Add(final k1 = wp, final k2 = -1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 100, "y1": 100, "x2": 200, "y2": 200, "rot": 0},
        "diagram": {"iconName": "input", "x1": 100, "y1": 90, "x2": 200, "y2": 190, "rot": 0}
      },
      "tags": []
    }
  }
  add_d = BlockComponents.Math.Add(final k1 = wd, final k2 = -1) if with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 100, "y1": 300, "x2": 200, "y2": 400}}
    }
  }
  add_i = BlockComponents.Math.Add3(final k1 = 1, final k2 = -1, final k3 = 1) if with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 100, "y1": 500, "x2": 200, "y2": 600}}
    }
  }
  proportional = BlockComponents.Math.Gain(final k = 1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 300, "y1": 100, "x2": 400, "y2": 200, "rot": 0},
        "diagram": {"iconName": "input", "x1": 300, "y1": 90, "x2": 400, "y2": 190, "rot": 0}
      },
      "tags": []
    }
  }
  derivative = Derivative(final k = Td, final T = max(Td / Nd, 1e-14), final x0 = xd0) if with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 300, "x2": 400, "y2": 400}}
    }
  }
  integrator = Integrator(final k = 1 / Ti, final x0 = xi0) if with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 500, "x2": 400, "y2": 600}}
    }
  }
  "Zero contribution of the structurally removed derivative part"
  zero_d = BlockComponents.Sources.Constant(final k = 0) if !with_D {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 300, "x2": 400, "y2": 400}}
    }
  }
  "Zero contribution of the structurally removed integral part"
  zero_i = BlockComponents.Sources.Constant(final k = 0) if !with_I {
    "Dyad": {
      "placement": {"icon": {"iconName": "input", "x1": 300, "y1": 500, "x2": 400, "y2": 600}}
    }
  }
  add_pid = BlockComponents.Math.Add3(final k1 = 1, final k2 = 1, final k3 = 1) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 500, "y1": 300, "x2": 600, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 500, "y1": 120, "x2": 600, "y2": 220, "rot": 0}
      },
      "tags": []
    }
  }
  gain_pid = BlockComponents.Math.Gain(final k = k) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 700, "y1": 300, "x2": 800, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 550, "y1": 310, "x2": 650, "y2": 410, "rot": 0}
      },
      "tags": []
    }
  }
  add_ff = BlockComponents.Math.Add(final k1 = 1, final k2 = k_ff) {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 900, "y1": 300, "x2": 1000, "y2": 400, "rot": 0},
        "diagram": {"iconName": "input", "x1": 710, "y1": 340, "x2": 810, "y2": 440, "rot": 0}
      },
      "tags": []
    }
  }
  #    NOTE: using final for these parameters causes a bug.  
  #          see https://github.com/JuliaComputing/dyad-lang/issues/1640
  limiter = BlockComponents.Nonlinear.Limiter(y_max = y_max, y_min = y_min) {
    "Dyad": {"placement": {"diagram": {"x1": 870, "x2": 970, "y1": 450, "y2": 550}}}
  }
  add_sat = BlockComponents.Math.Add(final k1 = 1, final k2 = -1) if with_I {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 1100, "y1": 500, "x2": 1200, "y2": 600, "rot": 90},
        "diagram": {"iconName": "input", "x1": 800, "y1": 590, "x2": 900, "y2": 690, "rot": 90}
      },
      "tags": []
    }
  }
  gain_track = BlockComponents.Math.Gain(final k = 1 / (k * Ni)) if with_I {
    "Dyad": {
      "placement": {
        "icon": {"iconName": "input", "x1": 500, "y1": 700, "x2": 600, "y2": 800, "rot": 180}
      }
    }
  }
  variable control_error::Real
  "Whether or not to include the integral part"
  structural parameter with_I::Boolean = true
  "Whether or not to include the derivative part"
  structural parameter with_D::Boolean = true
  "Gain of controller"
  parameter k::Real = 1
  "Time constant of the integrator block (only active if `with_I = true`)"
  parameter Ti::Time = 0.5
  "Time constant of the derivative block (only active if `with_D = true`)"
  parameter Td::Time = 0.1
  "Maximum output"
  parameter y_max::Real = 1e300
  "Minimum output"
  parameter y_min::Real = -y_max
  "Set-point weight for proportional block"
  parameter wp::Real = 1
  "Set-point weight for derivative block (only active if `with_D = true`)"
  parameter wd::Real = 1
  "`Ni*Ti` is time constant of anti-windup compensation (only active if `with_I = true`)"
  parameter Ni::Real = 0.9
  "Maximum derivative gain. Higher the value of `Nd`, the more ideal the derivative block gets (less filtering, higher high-frequency gain). (only active if `with_D = true`)"
  parameter Nd::Real = 10
  "Gain of the feed-forward input"
  parameter k_ff::Real = 1
  "Initial guess value for integrator output (only active if `with_I = true`)"
  parameter xi0::Real = 0
  "Initial guess value for derivative output (only active if `with_D = true`)"
  parameter xd0::Real = 0
relations
  connect(add_p.y, proportional.u) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(proportional.y, add_pid.u1) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(add_pid.y, gain_pid.u) {
    "Dyad": {
      "edges": [
        {
          "S": 1,
          "M": [
            {"x": 650, "y": 170},
            {"x": 650, "y": 260},
            {"x": 510, "y": 260},
            {"x": 510, "y": 360}
          ],
          "E": 2
        }
      ],
      "renderStyle": "standard"
    }
  }
  connect(gain_pid.y, add_ff.u1) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}], "renderStyle": "standard"}}
  connect(add_ff.y, limiter.u) {
    "Dyad": {"edges": [{"S": 1, "M": [{"x": 840, "y": 390}, {"x": 840, "y": 500}], "E": 2}]}
  }
  control_error = u_s - u_m
  connect(limiter.y, y) {"Dyad": {"edges": [{"S": 1, "M": [], "E": 2}]}}
  connect(add_ff.u2, u_ff) {
    "Dyad": {
      "edges": [
        {
          "S": 1,
          "M": [{"x": 670, "y": 420}, {"x": 670, "y": 80}, {"x": 500, "y": 80}],
          "E": 2
        }
      ],
      "renderStyle": "standard"
    }
  }
  connect(add_p.u1, u_s) {
    "Dyad": {
      "edges": [{"S": 1, "M": [{"x": 20, "y": 110}, {"x": 20, "y": 270}], "E": 2}],
      "renderStyle": "standard"
    }
  }
  connect(u_m, add_p.u2) {
    "Dyad": {
      "edges": [{"S": 1, "M": [{"x": 50, "y": 730}, {"x": 50, "y": 170}], "E": 2}],
      "renderStyle": "standard"
    }
  }
  if with_D
    connect(add_d.y, derivative.u) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(derivative.y, add_pid.u2) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 452.5, "y": 350}, {"x": 452.5, "y": 170}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_d.u1, u_s) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 20, "y": 320}, {"x": 20, "y": 270}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_d.u2, u_m) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 50, "y": 380}, {"x": 50, "y": 730}], "E": 2}],
        "renderStyle": "standard"
      }
    }
  else
    connect(zero_d.y, add_pid.u2) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
  end
  if with_I
    connect(add_i.y, integrator.u) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(integrator.y, add_pid.u3) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 490, "y": 550}, {"x": 490, "y": 200}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(limiter.y, add_sat.u1) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
    connect(add_sat.y, gain_track.u) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 850, "y": 750}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(gain_track.y, add_i.u3) {
      "Dyad": {"edges": [{"S": 1, "M": [{"x": 75, "y": 750}, {"x": 75, "y": 580}], "E": 2}]}
    }
    connect(add_i.u1, u_s) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 20, "y": 520}, {"x": 20, "y": 270}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_i.u2, u_m) {
      "Dyad": {
        "edges": [{"S": 1, "M": [{"x": 50, "y": 550}, {"x": 50, "y": 730}], "E": 2}],
        "renderStyle": "standard"
      }
    }
    connect(add_ff.y, add_sat.u2) {
      "Dyad": {
        "edges": [
          {
            "S": 1,
            "M": [{"x": 830, "y": 390}, {"x": 830, "y": 545}, {"x": 820, "y": 545}],
            "E": 2
          }
        ],
        "renderStyle": "standard"
      }
    }
  else
    connect(zero_i.y, add_pid.u3) {"Dyad": {"edges": [{"S": 1, "E": 2}]}}
  end
metadata {
  "Dyad": {
    "labels": [{"label": "$(instance)", "x": 500, "y": 1100, "rot": 0}],
    "icons": {"default": "dyad://BlockComponents/LimPID.svg"}
  }
}
end

Test Cases

No test cases defined.

Scalar Types

Partial Types

Enumerated Types

Function Types

Partial Types

Enumerated Types

Partial Types

Enumerated Types

Partial Types

Enumerated Types

Partial Types

Scalar Types

Partial Types

Partial Types

Types

Partial Types

Enumerated Types

Struct Types

Connectors

Components

Analyses

Examples

Tests

Scalar Types

Partial Types

Enumerated Types

Continuous.LimPID ​

Usage ​

Parameters: ​

Connectors ​

Variables ​

Behavior ​

Source ​

Test Cases ​

Related ​

`Continuous.LimPID`

Usage

Parameters:

Connectors

Variables

Behavior

Source

Test Cases

Related