For many systems, it seems to be common practice to stack controllers on top of each other. For example, in a quadcopter, one first builds an attitude controller, then builds a velocity controller whose (virtual) control variable is an input to the attitude controller, then builds a position controller whose (virtual) control variable is an input to the velocity controller. I believe (correct me if I'm wrong) that this is known as cascade control.
I'm wondering if there is any theory formalizing why this approach works. To be more precise, suppose I have the following two systems:
- $x' = f(x,u)$ (e.g. a position controller with virtual control variable $u$)
- $y' = g(y,v)$ (e.g. a velocity controller with actual control variable $v$)
Furthermore, suppose I have feedback control $a(x)$ that stabilizes the first system and $b(y)$ that stabilizes the second. In other words, the following two systems are asymptotically stable:
- $x' = f(x, a(x))$
- $y' = g(y, b(y))$
Now we can form the cascade of these two systems, which I believe is formalized as:
- $x' = f(x, y)$
- $y' = g(y, b(y - a(x)))$
It seems like cascade controller designers rely on the fact that this cascade will be asymptotically stable because the two subsystems are separately asymptotically stable. However, something tells me that this is not in general true. I feel like I'm missing something. Are there conditions under which this cascade is asymptotically stable (e.g. f and g are linear)? If not, how does one design an asymptotically stable cascade controller?
I did come upon a technique called backstepping, which builds feedback control for a system using feedback control for a subsystem and a Lyapunov function for the subsystem. For example, if you have feedback control a(x) which stabilizes $x' = f(x) + g(x)*a(x)$ and you have a Lyapunov function guaranteeing this stability, then you can build a function $b(x)$ stabilizing
- $x' = f(x) + g(x)*y$
- $y' = h(y) + j(y)*b(x)$
Unfortunately, I don't think that this approach quite solves my problem. Backstepping would be a way of producing a controller that stabilizes position via acceleration, given a controller that stabilizes position via velocity. However, I want to produce a controller that stabilizes position via acceleration, given a controller that stabilizes position via velocity and a fixed controller that stabilizes velocity via acceleration. This would allow me to modularly build an attitude controller, then a velocity controller on top of that, then a position controller on top of that, etc.