ControlSystems.jl

In ControlSystems.jl, calculation functions and plotting functions are strictly separated:

1. Calculation functions (e.g., bode, nyquist, step, lsim) return data structures or arrays containing the results. They never produce a plot themselves.
2. Plotting functions (e.g., bodeplot, nyquistplot) are used to visualize the results of the calculation functions.

There are no dedicated plotting functions for time-domain results (like step, impulse, or lsim responses). Instead, these functions return a ControlSystemsBase.SimResult object. To visualize the response, simply call the standard plot() function directly on the result object.

# Example: Plotting a step response
sys = tf([1], [1, 1])
res = step(sys, 5)
plot(res)

When standard rational control-design methods fail due to time delays, consider these alternative approaches:

• Padé Approximation: Use the pade function to approximate the delay as a rational function. Note: This can introduce RHP zeros and fail to capture high-frequency phase loss.
• Discretization: Discretize the system with a sample time that is an integer multiple of the delay time. This allows exact representation in discrete time, though small sample times relative to the delay increase the state count.
• Robust Design: Neglect the delay during design but use large phase and delay margins to compensate.
• Uncertainty Modeling: Model the delay as an uncertainty (available via the RobustAndOptimalControl.jl extension).
• Frequency-Domain Methods: Use manual loop shaping or optimization-based tuning, which handle delays natively.

ControlSystems.jl is a control systems design toolbox for Julia. It follows the patterns of major computer-aided control systems design (CACSD) toolboxes.

Key mental models include:

• System Representations: Systems can be represented as either Transfer Functions (tf) or State Space (ss) models.
• Composition: Individual systems can be combined into larger architectures.
• Simulation & Analysis: Systems can be simulated in both the time domain (e.g., step, impulse) and frequency domain (e.g., bode, nyquist), and analyzed for stability and performance properties.

The types used in ControlSystemsBase.jl respect the types of the inputs provided. Specifically, the distinction between integers and floats matters:

• tf(1, [1, 1]) creates a transfer function with integer coefficients.
• tf(1.0, [1, 1]) promotes all coefficients to Float64.

Be mindful of this when defining systems to avoid unexpected integer arithmetic or to ensure floating-point precision.

# Integer coefficients
sys_int = tf(1, [1, 1])

# Float64 coefficients
sys_float = tf(1.0, [1, 1])

Sampling introduces modulation. For an input with frequency $\omega$, the output will contain frequencies $\omega \pm \omega_s k$, where $\omega_s$ is the sampling frequency and $k$ is an integer.

When performing frequency-domain analysis, be aware that the discrete-time simulation (using a discretized plant) may fail to capture high-frequency dynamics or continuous disturbances correctly if they approach or exceed the Nyquist frequency. In such cases, using a continuous-time model with an exact translation of the controller (d2c_exact) is preferred for stability analysis.

Selecting the right filters is critical for convergence and robustness:

1. Learning Filter $L(q)$: Controls the step size.

   • A heuristic choice is a scaled lookahead: $L = 0.5z^l$.
   • A model-based approach uses the inverse of the closed-loop system: $L = 0.5 \text{inv}(G_c)$.
   • Scaling $L$ by a constant $< 1$ makes learning slower but more robust.

2. Robustness Filter $Q(q)$: Controls frequency content to handle noise and modeling errors.

   • Typically a low-pass filter.
   • When used with lsim_zerophase, the effective transfer function is $Q(z)Q(\bar{z})$.

Convergence Condition: For ILC to converge, the following must hold: $$| 1 - LG | < |Q^{-1}|$$ You can verify this by checking if the Bode plot of $|1 - LG|$ stays below the stability boundary $|Q^{-1}|$.

ControlSystems.jl represents nonlinear feedback systems using a linear-fractional transform (LFT) between a linear system P and a diagonal matrix of scalar nonlinear functions $f$. This approach allows nonlinearities to be treated similarly to delay systems within the framework.

To create a nonlinear component, use the nonlinearity(f) function, where f is your nonlinear function. This returns a primitive system that behaves like a standard LTISystem during algebraic operations, allowing you to compose it with linear systems to form feedback loops.

# Example of creating a nonlinearity primitive
f(u) = u^3
nl = nonlinearity(f)