Hubbry Logo
Integral windupIntegral windupMain
Open search
Integral windup
Community hub
Integral windup
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Integral windup
Integral windup
Integral windup
View on Wikipedia
from Wikipedia

Integral windup, also known as integrator windup[1] or reset windup,[2] refers to the situation in a PID controller where a large change in setpoint occurs (say a positive change) and the integral term accumulates a significant error during the rise (windup), thus overshooting and continuing to increase as this accumulated error is unwound (offset by errors in the other direction).

Solutions

[edit]

This problem can be addressed by

  • Initializing the controller integral to a desired value, for instance to the value before the problem[citation needed]
  • Increasing the setpoint in a suitable ramp
  • Conditional integration: disabling the integral function until the to-be-controlled process variable (PV) has entered the controllable region[3]
  • Preventing the integral term from accumulating above or below pre-determined bounds[4]
  • Back-calculating the integral term to constrain the process output within feasible bounds.[5][6][3]
  • Clegg integrator: Zeroing the integral value every time the error is equal to, or crosses zero.[7] This avoids having the controller attempt to drive the system to have the same error integral in the opposite direction as was caused by a perturbation, but induces oscillation if a non-zero control value required to maintain the process at setpoint.[8]

Occurrence

[edit]

Integral windup particularly occurs as a limitation of physical systems, compared with ideal systems, due to the ideal output being physically impossible (process saturation: the output of the process being limited at the top or bottom of its scale, making the error constant). For example, the position of a valve cannot be any more open than fully open and also cannot be closed any more than fully closed. In this case, anti-windup can actually involve the integrator being turned off for periods of time until the response falls back into an acceptable range.

This usually occurs when the controller's output can no longer affect the controlled variable, or if the controller is part of a selection scheme and it is selected right.

Integral windup was more of a problem in analog controllers. Within modern distributed control systems and programmable logic controllers, it is much easier to prevent integral windup by either limiting the controller output, limiting the integral to produce feasible output,[5] or by using external reset feedback, which is a means of feeding back the selected output to the integral circuit of all controllers in the selection scheme so that a closed loop is maintained.

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Integral windup

View on Grokipedia
from Grokipedia
Integral windup, also known as integrator windup or reset windup, is a common issue in proportional--derivative (PID) controllers where the term continuously accumulates error over time while the system's is saturated, preventing the controller output from effectively driving the process variable toward the setpoint. This accumulation, often described as the term becoming "wound up" beyond its normal limits, results in a delayed or unstable system response once the saturation condition is relieved. The primary cause of integral windup arises from actuator saturation, where physical limitations—such as a valve fully open or a motor at maximum speed—prevent the control signal from further influencing the process, yet the integral action continues to integrate the persistent error. Additional triggers include large setpoint changes that produce sustained errors exceeding the system's response capability, or unmeasured external disturbances that force the actuator to its limits. For instance, if a setpoint demands a motor speed of 1700 RPM but the motor is limited to 1600 RPM, the error persists, allowing the integral term to build excessively. The effects of integral windup significantly impair control performance, often leading to excessive overshoot, prolonged times, or even system oscillations and as the accumulated integral must first "unwind" before correcting the error. In practical applications, such as or systems, this can result in sluggish recovery after setpoint adjustments or disturbances, potentially causing equipment wear or safety issues. To mitigate integral windup, various anti-windup techniques are employed, including integrator clamping, which freezes the accumulation when the controller output reaches saturation limits. Back-calculation methods adjust the term by feeding back the difference between the saturated and unsaturated control signals, while conditional integration halts integration when the exceeds a threshold or during saturation. Other approaches, such as setpoint or resetting the upon mode switches (e.g., from manual to automatic), further enhance robustness in PID implementations across engineering domains.

Background

PID Controllers

A proportional–integral–derivative (PID) controller is a feedback control mechanism that calculates an error value as the difference between a desired setpoint and a measured , then applies a correction based on proportional, , and terms to minimize this error and achieve stable control. The proportional term provides an output proportional to the current error, offering immediate response; the term sums past errors to address accumulated discrepancies; and the term predicts future error based on the rate of change, helping to dampen oscillations. This combination enables precise regulation in dynamic systems by balancing responsiveness, accuracy, and stability. The mathematical representation of a PID controller in continuous time is given by: u(t)=Kpe(t)+Ki∫0te(τ) dτ+Kdde(t)dtu(t) = K_p e(t) + K_i \int_0^t e(\tau) \, d\tau + K_d \frac{de(t)}{dt} where u(t)u(t) is the control signal output, e(t)e(t) is the error signal (setpoint minus ), and KpK_p, KiK_i, KdK_d are the tunable proportional, , and gains, respectively. These parameters are adjusted during tuning to optimize performance for specific applications, often using methods like Ziegler-Nichols to balance trade-offs between speed and overshoot. PID control originated in the early , with the first theoretical analysis published by Nicolas Minorsky in for automatic ship , marking the formal development of the three-term approach for . It gained widespread adoption in starting in the , initially through pneumatic and hydraulic implementations before transitioning to electronic forms. Today, PID controllers remain ubiquitous in applications such as temperature regulation in chemical processes, speed control in electric motors, and position servos in and equipment, due to their simplicity, robustness, and effectiveness across diverse industries. The integral term plays a key role in eliminating steady-state error by integrating the error over time.

Integral Term Function

The integral term in a PID controller serves to accumulate the history of the signal over time, thereby eliminating steady-state in systems subject to constant disturbances or setpoint offsets. By integrating the , it provides a control action that grows proportionally to the duration and magnitude of the deviation, ensuring that the system's output eventually aligns precisely with the desired setpoint without requiring manual intervention. In normal operation, the integral term is mathematically expressed as I(t)=Ki∫0te(τ) dτ,I(t) = K_i \int_0^t e(\tau) \, d\tau, where KiK_i is the gain, e(τ)e(\tau) is the at time τ\tau, and the integral sums past errors to generate an adjustment in the control signal that counteracts persistent biases. This accumulation builds gradually, allowing the term to dominate when proportional action alone proves insufficient, thus driving the overall error toward zero. A key advantage of the term is its ability to enhance accuracy in processes requiring tight regulation, such as level control in a , where alone would result in a persistent offset due to uncompensated disturbances like inflow variations. In such applications, the integral action ensures the level stabilizes exactly at the setpoint, improving overall precision without steady-state deviation. Under ideal conditions without actuator constraints, the integral term's effectiveness depends on the choice of KiK_i; a small value may lead to a sluggish response, prolonging the time needed to eliminate steady-state error, while careful tuning is essential to balance responsiveness and stability.

Causes

Actuator Saturation

saturation refers to the condition in which a control signal demanded by the controller exceeds the physical or operational limits of the , rendering it incapable of further response and effectively opening the feedback loop. This phenomenon arises because , such as or valves, have inherent constraints on their output range, preventing them from producing the full corrective action required to reduce the system error. Common examples include electric actuators in motor drives, which clip their output at ±100% of the maximum voltage or current capacity, and hydraulic or pneumatic valves in systems that become fully open or closed beyond certain bounds. In , servo motors often saturate during rapid trajectory changes, limiting output, while in (HVAC) systems, damper actuators or units reach endpoints when responding to extreme demands. These limits ensure safe operation but introduce nonlinearity into otherwise linear control designs. In PID controllers, the output u(t)u(t) is computed based on the error signal but subsequently clipped to the 's saturation limits, which halts the intended error correction and allows discrepancies to persist without adjustment. This interaction disrupts the controller's ability to track the setpoint accurately, particularly when the integral term accumulates based on uncorrected errors. Actuator saturation is prevalent in practical nonlinear systems, such as and HVAC, where transient demands frequently spike beyond actuator capabilities, affecting a significant portion of industrial deployments.

Prolonged Error Integration

In PID control systems, prolonged error integration occurs when the actuator reaches its saturation limit, yet the error signal e(t)e(t) persists as nonzero—for instance, remaining positive if the setpoint has not been achieved. Consequently, the integral term continues to accumulate this error without restraint, as the integration process ∫e(τ) dτ\int e(\tau) \, d\tau proceeds unchecked despite the limited effective control action. This mechanism is a core aspect of integral windup, where the unchecked inflates the integral component over extended periods. The resulting excessive value in the term defines the "wound-up" state, in which the controller's output adheres to the saturation boundary even as the process diminishes or reverses. This buildup happens because the saturation affects only the output, not the internal computation of the , allowing persistent contributions to dominate the accumulator. Mathematically, during saturation where the effective control signal is clamped at u(t)=umax⁡u(t) = u_{\max}, the internal term still evolves as I(t)=I(t−1)+Kie(t)ΔtI(t) = I(t-1) + K_i e(t) \Delta t in discrete-time implementations, causing I(t)I(t) to inflate progressively with each sampling interval. In continuous form, this corresponds to I(t)=Ki∫0te(τ) dτI(t) = K_i \int_0^t e(\tau) \, d\tau, which grows linearly with the duration and magnitude of the nonzero . High gain KiK_i exacerbates this accumulation by scaling the contributions more aggressively, accelerating the windup. Such prolonged integration typically manifests in scenarios involving abrupt step changes in setpoint or disturbances, like load shifts, that sustain saturation for extended durations.

Effects

Overshoot Behavior

windup manifests as excessive overshoot in the controlled variable when the desaturates after a period of saturation. During saturation, the term continues to accumulate , building a large value for the integral state I(t). Upon desaturation, this accumulated I(t) combines with the proportional and derivative terms to produce a control signal u(t) that is excessively large, driving the process variable beyond the setpoint before the reverses and the begins to unwind./09%3A_Proportional-Integral-Derivative_(PID)_Control/9.06%3A_PID_Downsides_and_Solutions) A representative example occurs in a heating system where the heater is saturated at maximum output while the lags behind the setpoint. The term integrates the persistent over this period, amassing a significant value. Once the approaches the setpoint and the desaturates, the oversized drives the heater beyond the required level, causing the to overshoot the setpoint and potentially trigger cooling if present./09%3A_Proportional-Integral-Derivative_(PID)_Control/9.06%3A_PID_Downsides_and_Solutions) The severity of this overshoot depends on the duration of saturation and the integral gain K_i; longer saturation periods allow greater error accumulation, while higher K_i amplifies the effect of that accumulation. In marginally systems, this can induce oscillations as the process variable swings past the setpoint and the integral overcorrects in the opposite direction./09%3A_Proportional-Integral-Derivative_(PID)_Control/9.06%3A_PID_Downsides_and_Solutions) Simulation studies of step responses in PID-controlled systems demonstrate this behavior clearly, with windup leading to large overshoots—often significantly greater than in non-windup cases—before settling, as shown in response curves where the process variable exceeds the setpoint by substantial margins during recovery from saturation./09%3A_Proportional-Integral-Derivative_(PID)_Control/9.06%3A_PID_Downsides_and_Solutions)

Settling Time Increase

Integral windup prolongs the in PID-controlled systems by causing the term I(t)I(t) to accumulate excessively during actuator saturation, such that after an initial overshoot, the subsequent negative error must slowly unwind this large accumulated value before the output can stabilize within a specified tolerance band, typically 2-5% of the setpoint. This unwinding process delays the system's return to steady-state, as the controller output remains biased until the corrects itself through ongoing error integration. The impact on can be substantial, extending it from nominal values on the order of seconds to minutes in saturated conditions, and in severe cases, leading to limit cycles or even system divergence due to persistent from the over-accumulated . For instance, in simulations of second-order systems with saturation limits of ±100, the 2% exceeds 2 seconds following a step input, compared to under 1 second when the is properly limited to ±10. Such delays degrade overall performance, increasing metrics like the integral absolute error (IAE), which quantifies the total accumulated deviation as IAE=∫0∞∣e(t)∣ dt\text{IAE} = \int_0^\infty |e(t)| \, dt, thereby highlighting the extent of temporal inefficiency introduced by windup. In real-world applications, such as chemical reactors, prolonged times to reduce throughput and yield by maintaining the system away from optimal operating conditions longer than necessary, potentially leading to suboptimal reaction rates or product quality variations. For second-order systems approximating many , the is theoretically given by ts≈4ζωnt_s \approx \frac{4}{\zeta \omega_n} for a 2% criterion, where ζ\zeta is the and ωn\omega_n is the natural ; windup effectively reduces ζ\zeta during recovery, further inflating tst_s.

Anti-Windup Techniques

Clamping Integration

Clamping integration, also known as conditional integration or integrator clamping, is an anti-windup technique designed to mitigate windup in PID controllers by preventing the integral term from accumulating beyond predefined limits during periods of saturation. This method directly constrains the integral action when the controller output would otherwise exceed the actuator's operational bounds, thereby avoiding excessive error integration that contributes to overshoot behavior upon return to the linear range. The approach is particularly suited for systems where saturation occurs frequently but briefly, such as in process control applications. In practice, when the unsaturated control signal u(t)u(t) exceeds the maximum limit umax⁡u_{\max} or falls below umin⁡u_{\min}, the term I(t)I(t) is held constant rather than updated with the error signal. Alternatively, it may be reset to a value that aligns the total output with the saturation limit, such as I(t)=umax⁡Ki−P(t)−D(t)I(t) = \frac{u_{\max}}{K_i} - P(t) - D(t) for upper saturation, where KiK_i is the gain, and P(t)P(t) and D(t)D(t) are the proportional and terms. The constrained is then computed as I(t)=min⁡(max⁡(I(t),Imin⁡),Imax⁡),I(t) = \min\left( \max\left( I(t), I_{\min} \right), I_{\max} \right), with bounds Imin⁡I_{\min} and Imax⁡I_{\max} derived from the range to the full PID output stays within limits regardless of variations in P(t)P(t) and D(t)D(t). This clamping logic is implemented via simple conditional checks in the controller algorithm. Variants of clamping include hard clamping, which completely stops updates during saturation, and soft clamping, which dynamically reduces the gain KiK_i by a factor (typically 0.05 to 0.25) to allow partial accumulation while limiting windup. Hard clamping provides abrupt prevention of over-integration but can delay recovery, whereas soft clamping offers smoother by permitting limited adjustment. Advantages of clamping integration lie in its simplicity and ease of implementation in basic digital controllers without requiring additional feedback loops, effectively reducing windup-induced transients in startup or disturbance scenarios. However, it may introduce phase lag by halting or slowing action, potentially leading to steady-state offset if saturation persists, and it is less effective for prolonged saturation periods where the fails to adapt.

Back-Calculation Method

The back-calculation method addresses integral windup in PID controllers by introducing a feedback mechanism that dynamically adjusts the term based on the difference between the unsaturated controller output and the saturated output. This approach ensures that the accumulator is "unwound" at a rate proportional to the saturation level, preventing excessive buildup during periods when the is limited. In , the method incorporates a tracking TtT_t, which determines the speed of the unwinding process and is typically set equal to or a fraction of the TiT_i for balanced performance. The update to the term I(t)I(t) is given by: I(t)=I(t)−u(t)−usat(t)TtI(t) = I(t) - \frac{u(t) - u_{\text{sat}}(t)}{T_t} where u(t)u(t) is the unsaturated PID output and usat(t)u_{\text{sat}}(t) is the saturated actuator signal. This feedback loop activates whenever saturation occurs, effectively tracking the actuator limitations to maintain system stability. One key benefit of back-calculation is its ability to preserve the overall controller dynamics even during saturation events, allowing for smoother recovery once the actuator returns to its linear range. This method gained popularity in the 1980s through robust PID implementations discussed in control literature, building on earlier foundational work. The technique is widely adopted in industrial programmable logic controllers (PLCs), such as those from , where the PID instruction explicitly back-calculates the integral term to track saturation and enable bumpless transfer. Similarly, Siemens S7 PLCs implement back-calculation in their PID_Compact V2 blocks for override control, ensuring synchronized integral adjustments to mitigate windup. In simulations of saturated systems, back-calculation has been shown to substantially reduce times compared to controllers without anti-windup.

Conditional Integration

Conditional integration is an anti-windup technique that modifies the term in PID controllers by updating it only under specific conditions related to the signal or output, thereby preventing excessive accumulation during saturation. In this method, the action I(t)I(t) is frozen or held constant when the absolute ∣e(t)∣|e(t)| exceeds a predefined threshold, such as ∣e(t)∣≥e0|e(t)| \geq e_0, or when the controller output is saturated; otherwise, it proceeds with normal integration dI(t)dt=Kie(t)\frac{dI(t)}{dt} = K_i e(t). This approach ensures that the does not build up during periods of prolonged , which often occur due to limitations. Variants of conditional integration include error-based and output-based implementations. In error-based conditional integration, the integral updates only if the error e(t)e(t) and its derivative de(t)dt\frac{de(t)}{dt} have the same sign, indicating that the error is not reversing direction, or if ∣e(t)∣|e(t)| remains below a threshold to preserve action for small disturbances. Output-based variants, such as those using a predicted output yp(t)y_p(t), halt integration if the projected falls outside a proportional band defined by saturation limits, like [yl(t),yh(t)][y_l(t), y_h(t)] where yl(t)=br(t)+I(t)−umax⁡/Kpy_l(t) = br(t) + I(t) - u_{\max}/K_p and yh(t)=br(t)+I(t)−umin⁡/Kpy_h(t) = br(t) + I(t) - u_{\min}/K_p. These variants help tailor the technique to different , with error-based being simpler for tracking small s and output-based providing direct ties to constraints. The primary advantages of conditional integration lie in its ability to maintain integral action for minor errors while simply freezing the accumulator during saturation, making it particularly suitable for digital controllers where is straightforward without additional feedback loops. It reduces overshoot and improves times in systems prone to windup, as demonstrated in comparative studies of PID tuning under saturation. However, drawbacks include potential "bump" effects—sudden jumps in control output when conditions switch abruptly—and reduced effectiveness in systems with fast dynamics, where the threshold tuning can lead to chattering or incomplete windup prevention. In discrete-time implementations, common in digital control systems, the integral term is updated as I(k)=I(k−1)+Kie(k)ΔtI(k) = I(k-1) + K_i e(k) \Delta t if the is not saturated and ∣e(k)∣<e0|e(k)| < e_0; otherwise, I(k)=I(k−1)I(k) = I(k-1) to freeze the value. This formulation aligns with standard PID blocks in simulation tools and ensures computational efficiency by avoiding unnecessary accumulation.

Implementation Considerations

Tuning Adjustments

Tuning adjustments for PID controllers aim to minimize integral windup susceptibility by carefully selecting proportional (Kp), integral (Ki), and derivative (Kd) gains during the design phase, focusing on systems where actuator saturation is likely. Reducing Ki slows the accumulation of the integral term, limiting excessive buildup during prolonged errors and thereby decreasing windup risk in saturating environments. Increasing Kp enhances the initial response to deviations, allowing the controller to correct errors more quickly without heavy dependence on integration. Incorporating Kd provides against overshoot, stabilizing the system response when integral action might otherwise amplify oscillations post-saturation. Established methods like adaptations of the Ziegler-Nichols tuning rules can be employed for anti-windup considerations, where gains are selected more conservatively to account for saturation effects, often resulting in larger times compared to standard aggressive settings. Similarly, the SIMC (Simple Industrial Model Control) rules offer robust, conservative PID tuning guidelines that prioritize stability in the presence of constraints, with times set to match dominant time constants for reduced windup propensity. To refine these gains, simulations incorporating saturation models are essential, enabling iterative testing to achieve desired performance such as overshoot below 10% and acceptable settling times under constrained conditions. Best practices include initializing with low Ki values to ensure conservative action from the outset, followed by gradual increases while observing system behavior. Real-time monitoring of the term's contribution via logs helps identify and mitigate emerging windup during operation. Software tools such as and facilitate windup-aware tuning through dedicated PID blocks and interactive tuners that model saturation and optimize gains for balanced performance.

Software Examples

In and , the PID Controller block supports anti-windup through clamping integration, which conditionally halts the integral term when the controller output saturates. This example models a first-order process with dead-time, P(s)=110s+1e−2sP(s) = \frac{1}{10s+1} e^{-2s}, and actuator limits of [-10, 10]. Without anti-windup, a setpoint change from 0 to 10 causes the controller output to exceed limits, leading to prolonged overshoot and delayed recovery when the setpoint drops to 5. Enabling clamping in the block configuration ensures the saturated output feeds back to prevent integral accumulation, resulting in quicker return to the linear operating region and reduced overshoot in the . In Python, the control systems library facilitates of PID controllers, with anti-windup often implemented manually via back-calculation for discrete systems. A representative discrete PID class incorporates proportional, , and derivative terms, applying back-calculation by feeding the difference between the unsaturated controller output and the saturated actuator signal back to the with a gain KbK_b. The following code snippet demonstrates this for a simple , where the term is adjusted only when saturation occurs:

python

import numpy as np import matplotlib.pyplot as plt from control import ss, forced_response class DiscretePID: def __init__(self, Kp, Ki, Kd, dt, Kb=1.0, u_min=0, u_max=100): self.Kp = Kp self.Ki = Ki * dt self.Kd = Kd / dt self.Kb = Kb self.dt = dt self.u_min, self.u_max = u_min, u_max self.prev_error = 0 self.integral = 0 self.prev_u = 0 def update(self, setpoint, measurement): error = setpoint - measurement P = self.Kp * error I = self.integral + self.Ki * error D = self.Kd * (error - self.prev_error) u_unsat = P + I + D u_sat = np.clip(u_unsat, self.u_min, self.u_max) if u_sat != u_unsat: self.integral = I + self.Kb * (u_sat - u_unsat) else: self.integral = I self.prev_error = error self.prev_u = u_sat return u_sat # Example simulation (plant: simple integrator for demo) dt = 0.1 t = np.arange(0, 20, dt) setpoint = np.ones_like(t) * 50 y = np.zeros_like(t) pid = DiscretePID(Kp=1, Ki=0.5, Kd=0.1, dt=dt) u = np.zeros_like(t) for i in range(1, len(t)): u[i] = pid.update(setpoint[i], y[i-1]) y[i] = y[i-1] + 0.1 * u[i] * dt # Simple plant dynamics plt.plot(t, y, label='Output with anti-windup') # Compare with no anti-windup by setting Kb=0 in init

import numpy as np import matplotlib.pyplot as plt from control import ss, forced_response class DiscretePID: def __init__(self, Kp, Ki, Kd, dt, Kb=1.0, u_min=0, u_max=100): self.Kp = Kp self.Ki = Ki * dt self.Kd = Kd / dt self.Kb = Kb self.dt = dt self.u_min, self.u_max = u_min, u_max self.prev_error = 0 self.integral = 0 self.prev_u = 0 def update(self, setpoint, measurement): error = setpoint - measurement P = self.Kp * error I = self.integral + self.Ki * error D = self.Kd * (error - self.prev_error) u_unsat = P + I + D u_sat = np.clip(u_unsat, self.u_min, self.u_max) if u_sat != u_unsat: self.integral = I + self.Kb * (u_sat - u_unsat) else: self.integral = I self.prev_error = error self.prev_u = u_sat return u_sat # Example simulation (plant: simple integrator for demo) dt = 0.1 t = np.arange(0, 20, dt) setpoint = np.ones_like(t) * 50 y = np.zeros_like(t) pid = DiscretePID(Kp=1, Ki=0.5, Kd=0.1, dt=dt) u = np.zeros_like(t) for i in range(1, len(t)): u[i] = pid.update(setpoint[i], y[i-1]) y[i] = y[i-1] + 0.1 * u[i] * dt # Simple plant dynamics plt.plot(t, y, label='Output with anti-windup') # Compare with no anti-windup by setting Kb=0 in init

Plotting the response reveals windup without back-calculation causes excessive overshoot and longer settling, while the mitigated case shows smoother tracking with reduced oscillation. Industrial software like implements anti-windup via sum correction in its PID VIs, which adjusts the accumulator when the output saturates to prevent windup during setpoint changes or mode switches. For systems in Studio 5000 Logix Designer, the PID instruction inherently includes anti-reset windup protection through conditional integration: the term freezes at .MAXO or .MINO limits until the moves within bounds, integrated directly into rungs without additional programming. This ensures bumpless transfer from manual to auto mode by back-calculating the using the set output (.SO) or tieback. In these examples, anti-windup significantly reduces times; for instance, in simulations of multi-pole processes, responses settle 1.5 to 2 seconds faster with compared to unprotected cases exhibiting prolonged oscillations. Open-source resources include repositories demonstrating integral windup, such as those providing minimal PID implementations with configurable anti-windup modes for educational simulations and tuning experiments. These often feature Jupyter notebooks or scripts comparing step responses, aiding in understanding effects like increased without mitigation.

References

  1. https://control.com/technical-articles/intergral-windup-method-in-pid-control/
  2. https://eng.libretexts.org/Bookshelves/Industrial_and_Systems_Engineering/Chemical_Process_Dynamics_and_Controls_%28Woolf%29/09%253A_Proportional-Integral-Derivative_%28PID%29_Control/9.06%253A_PID_Downsides_and_Solutions
  3. https://www.ni.com/en/shop/labview/pid-theory-explained.html
  4. https://iacsengineering.com/integral-windup/
  5. https://www.isa.org/intech-home/2023/june-2023/features/fundamentals-pid-control
  6. https://www.zhinst.com/en/resources/principles-of-pid-controllers
  7. https://www.controleng.com/understanding-pid-control-and-loop-tuning-fundamentals/
  8. https://www.ucg.ac.me/skladiste/blog_2146/objava_92847/fajlovi/Astrom.pdf
  9. https://www.emersonautomationexperts.com/2013/control-safety-systems/pid-control-history-and-advancements/
  10. https://engineering.purdue.edu/~zak/ECE_382-Fall_2018/IntroPID_16.pdf
  11. https://isl.charlotte.edu/coding/pid-control/
  12. https://www.cds.caltech.edu/~murray/books/AM08/pdf/am06-pid_16Sep06.pdf
  13. https://frcdocs.wpi.edu/en/2024/docs/software/advanced-controls/introduction/introduction-to-pid.html
  14. http://www.cds.caltech.edu/~murray/courses/cds101/fa02/caltech/astrom-ch6.pdf
  15. https://liquidinstruments.com/application-notes/understanding-actuator-saturation-in-control-systems/
  16. https://docs.wpilib.org/en/2020/docs/software/advanced-control/introduction/tuning-pid-controller.html
  17. https://admisiones.unicah.edu/Resources/lqWIro/4OK073/PidControllersTheoryDesignAndTuning.pdf
  18. https://kamman-dynamics-control.org/wp-content/uploads/2020/11/27-me471integratorwindup-1.pdf
  19. https://www.mdpi.com/2079-9292/11/24/4220
  20. http://experimentationlab.berkeley.edu/sites/default/files/PID_Theory_Explained.pdf
  21. https://eng.libretexts.org/Bookshelves/Industrial_and_Systems_Engineering/Chemical_Process_Dynamics_and_Controls_(Woolf)/09%3A_Proportional-Integral-Derivative_(PID)_Control/9.02%3A_P_I_D_PI_PD_and_PID_control
  22. https://ctms.engin.umich.edu/CTMS/index.php?example=Introduction&section=SystemAnalysis
  23. https://skoge.folk.ntnu.no/puublications_others/books/%C3%85strom-2006_Advanced%20PID%20Control/3.PID%20Control.pdf
  24. https://www.researchgate.net/publication/3352529_Modified_Anti-windup_scheme_for_PID_controllers
  25. https://www.ti.com/lit/ug/spruid3/spruid3.pdf
  26. https://www.mstarlabs.com/apeng/techniques/pidsoftw.html
  27. https://skoge.folk.ntnu.no/puublications_others/1989_Astrom-Rundqwist_anti-windup_ACC-conference.pdf
  28. https://www.rockwellautomation.com/en-tr/docs/factorytalk-design-studio/current/contents-ditamap/instructions/instruction-set/special-instructions/anti-reset-windup-bumpless-transfer-manual-auto--p.html
  29. https://cache.industry.siemens.com/dl/files/036/108210036/att_896030/v1/s71500_pid_control_function_manual_enUS_en-US.pdf
  30. https://penerbit.uthm.edu.my/ojs/index.php/ijie/article/download/1033/689
  31. https://www.sciencedirect.com/science/article/pii/S2314717216300034
  32. https://www.cds.caltech.edu/~murray/books/AM08/pdf/am08-pid_30Jan08.pdf
  33. https://cse.lab.imtlucca.it/~bemporad/teaching/ac/pdf/AC2-09-AntiWindup.pdf
  34. https://ieeexplore.ieee.org/document/6508138
  35. https://www.mathworks.com/help/simulink/slref/anti-windup-control-using-a-pid-controller.html
  36. https://www.wevolver.com/article/mastering-pid-tuning-the-comprehensive-guide
  37. https://www.researchgate.net/publication/372311940_Tuning_PID_Controller_Parameters_to_avoid_the_Effect_of_Integrator_Wind-up_by_using_The_Experimental-based_Heuristic_Approach
  38. https://www.mdpi.com/1424-8220/21/18/6157
  39. https://www.control.lth.se/fileadmin/control/Education/DoctorateProgram/ControlSystemsSynthesis/2020/PIDeight.pdf
  40. https://www.controleng.com/pid-spotlight-part-19-pid-controller-tuning-best-practices/
  41. https://www.mathworks.com/help/simulink/slref/pidcontroller.html
  42. https://github.com/python-control/python-control/discussions/845
  43. https://www.researchgate.net/publication/348349828_Performance_and_Configuration_Analysis_of_Tracking_Time_Anti-Windup_PID_Controllers
  44. https://www.ni.com/docs/en-US/bundle/labview-pid-and-fuzzy-logic-toolkit-api-ref/page/lvpidmain/pid_vi_algs.html
  45. https://www.rockwellautomation.com/en-in/docs/studio-5000-logix-designer/37-00/contents-ditamap/instruction-set/special-instructions/proportional-integral-derivative--pid-/anti-reset-windup-bumpless-transfer-manual-auto--p.html
  46. https://lup.lub.lu.se/luur/download?func=downloadFile&recordOId=3626764&fileOId=3626769
  47. https://github.com/asteppke/tinypid
  48. https://github.com/Dlloydev/QuickPID
Add your contribution
Related Hubs
User Avatar
No comments yet.