Non-Unity Feedback Systems

In the study of control systems, we often begin with the idealized concept of unity feedback, where the output is perfectly and instantaneously measured. However, real-world systems rely on physical sensors—thermometers, radars, tachometers—that possess their own dynamics, introducing delays and distortions. This discrepancy between the ideal and the real is the domain of ​​non-unity feedback​​. Ignoring these sensor dynamics can lead to critical design flaws, from persistent errors to catastrophic instability. This article addresses this knowledge gap by providing a comprehensive guide to understanding and mastering non-unity feedback systems. The first chapter, ​​Principles and Mechanisms​​, will demystify the core theory, explaining how to adapt standard stability analysis tools, the critical issue of internal instability, and the impact of sensor characteristics on system performance. Subsequently, the ​​Applications and Interdisciplinary Connections​​ chapter will illustrate how these principles manifest in real-world scenarios, from aerospace to robotics, revealing that accounting for the sensor is not a complication but a gateway to more sophisticated and robust design.

In our journey through control systems, we often start with a wonderfully simple picture: a feedback loop where the signal we measure and send back is a perfect, instantaneous replica of the system's output. We call this ​​unity feedback​​, because the "transfer function" of this perfect measurement is just the number 1. But as any physicist or engineer knows, the real world is rarely so accommodating. The instruments we use to measure things—thermometers, speedometers, pressure gauges, biosensors—are physical systems themselves. They have inertia, delays, and their own dynamic personalities. They don't just report the output; they filter it. This is the world of ​​non-unity feedback​​, and understanding its principles is not just an academic exercise; it's the key to making things work in reality.

Imagine you're trying to stand perfectly still by watching your reflection in a mirror. If it's a normal, flat mirror (unity feedback), the task is straightforward. But what if it's a funhouse mirror? It might make you look taller, shorter, or wiggle when you're standing still. The feedback you're getting is a distorted version of your actual posture. To stand still, you'd have to learn to compensate for the mirror's specific distortion.

In control systems, the forward path, $G(s)$, represents your brain and muscles trying to correct your posture, and the feedback path, $H(s)$, represents the mirror. In non-unity feedback, $H(s)$ is not just 1; it's a function that describes the dynamics of the sensor. A thermometer doesn't instantly read the water's temperature; it has to warm up itself. A car's speedometer might have a slight lag. These are all examples where $H(s) \neq 1$.

So, how do we analyze such a system? Do we need a whole new set of tools? Here lies the first beautiful piece of unity in this topic. For the most fundamental question—is the system stable?—it turns out the system doesn't care about the individual identities of $G(s)$ and $H(s)$. It only cares about what happens to a signal that makes one complete trip around the loop. We call this the ​​loop transfer function​​, $L(s) = G(s)H(s)$.

Whether we're using the Routh-Hurwitz criterion, drawing a Nyquist plot, or sketching a Root Locus, the starting point is always the system's ​​characteristic equation​​. For a negative feedback loop, this equation is universally $1 + L(s) = 0$, or $1 + G(s)H(s) = 0$.

• For a ​​Nyquist plot​​, we don't plot $G(s)$ or $H(s)$ alone; we plot the frequency response of the entire loop, $L(j\omega) = G(j\omega)H(j\omega)$, and see how it encircles the critical point $-1$. This tells us if a disturbance, after one trip around the loop, comes back bigger or smaller, in-phase or out-of-phase.

• For a ​​Root Locus diagram​​, which shows how the system's poles move as we tune a gain $k$, the locus is defined by the equation $1 + k \cdot L_{eq}(s) = 0$. If the gain $k$ is part of the forward path $G(s)$, the equivalent loop function for plotting is simply $L_{eq}(s) = G(s)H(s)$ (with the gain factored out).

The profound insight here is that stability is a property of the loop as a whole. The system is an interconnected dance, and it's the choreography of the entire circle, $G(s)H(s)$, that determines whether the dancers fly apart or settle into a stable formation.

This focus on the combined loop $L(s) = G(s)H(s)$ is powerful, but it comes with a serious warning label. It's tempting to perform algebraic simplification, canceling a zero in one part of the loop with a pole in another. Sometimes this is fine. But if the pole you're canceling is unstable (meaning it's in the right half of the complex plane), you are walking into a trap.

Consider an engineer designing a control system with a cheap sensor that happens to be unstable, having a pole at $s=2$. The engineer, being clever, designs a controller with a zero at $s=2$, thinking it will cancel out the sensor's instability. The combined loop function $L(s) = G(s)H(s)$ looks perfectly stable after the $(s-2)$ terms are canceled. The engineer builds the system, and it promptly fails, its output growing without bound.

What went wrong? The cancellation hid an unstable mode from the input-output analysis. The system is ​​internally unstable​​. Think of it like this: the unstable part of the sensor is like a ticking time bomb inside the system. The controller's zero acts like a pair of noise-canceling headphones for the final output, preventing us from hearing the ticking. But the bomb is still there, and eventually, it will explode. The true characteristic equation is found from the denominator of $1 + G(s)H(s)$ before any cancellation. In this case, the $(s-2)$ factor remains, guaranteeing an unstable pole in the closed-loop system, no matter what gain the engineer chooses. This is a crucial lesson: you cannot stabilize an unstable component in the loop by simply ignoring it with a cancellation.

While stability might only depend on the product $G(s)H(s)$, the system's actual performance—how well it does its job—depends critically on the individual components. A non-unity feedback path has direct, and often intuitive, consequences.

Let's imagine a high-precision PCR machine that needs to maintain a specific temperature. The system has a controller and a heating block ($G(s)$) and a temperature sensor ($H(s)$). Let's say we want the temperature to be $95^{\circ}\text{C}$, but our sensor isn't perfect. At steady-state (constant temperature), its gain is $H(0) = K_h$. If $K_h = 1.1$, it means the sensor over-reports the temperature by 10%. When the true temperature is $95^{\circ}\text{C}$, the sensor tells the controller it's $95 \times 1.1 = 104.5^{\circ}\text{C}$.

The controller's job is to make the measured temperature equal to the setpoint. So, the controller will adjust the heater until the sensor reports $95^{\circ}\text{C}$. But because the sensor is over-reporting, this will happen when the actual temperature is only $95 / 1.1 \approx 86.4^{\circ}\text{C}$. The system will have a significant ​​steady-state error​​. The controller has done its job perfectly based on the information it received, but the information was flawed. For a step input of magnitude $A$, the final error will be $e_{ss} = A(1 - 1/K_h)$. To get zero error, we need a sensor with a DC gain of exactly one ($K_h=1$).

This brings us to ​​sensitivity​​. What happens if our sensor's properties drift over time as it ages? The sensitivity of the overall system response $T(s)$ to changes in the sensor $H(s)$ is given by $S_H^T(s) = -\frac{G(s)H(s)}{1+G(s)H(s)}$. This tells us that if the loop gain $G(s)H(s)$ is small (much less than 1), the sensitivity is also small. This makes sense: if the feedback signal is weak, changes in it don't matter much. But if the loop gain is large, the sensitivity approaches $-1$, meaning a 1% change in the sensor's properties will cause a nearly 1% change in the overall system's behavior. A robust design often involves shaping the loop gain to be small in frequency ranges where the sensor is expected to be unreliable.

So, non-unity feedback complicates performance analysis. But what if we could "disguise" our non-unity system as a unity one? This would be incredibly useful, as a vast array of design techniques and software tools are created specifically for unity feedback systems.

This is indeed possible. We can find an ​​equivalent forward path​​, $G_{eq}(s)$, that, when placed in a unity feedback loop, produces the exact same overall input-output transfer function as our original non-unity system. A little bit of block diagram algebra reveals the magic formula:

Look at the denominator: $1 + G(s)(H(s) - 1)$. The term $H(s)-1$ represents the "imperfection" of our sensor—how much it deviates from an ideal sensor. The formula essentially says: take the original forward path $G(s)$ and modify it by incorporating a new minor loop that accounts for the sensor's imperfection. The resulting $G_{eq}(s)$ is a pre-distorted version of our plant model, corrected for the funhouse mirror. Now we can apply all our standard unity-feedback design tools to $G_{eq}(s)$, confident that the final design will work for the original, real-world system.

This transformation also reveals a subtle and important dynamic effect. The closed-loop transfer function can be written as $T(s) = \frac{G(s)}{1 + G(s)H(s)}$. If we write $G(s) = N_g(s)/D_g(s)$ and $H(s) = N_h(s)/D_h(s)$ as ratios of polynomials, this becomes:

The zeros of the overall system—the values of $s$ that block the output—are the roots of the numerator, $N_g(s) D_h(s)$. This means the closed-loop zeros are a combination of the ​​zeros of the forward path​​ ($G(s)$) and, surprisingly, the ​​poles of the feedback path​​ ($H(s)$). A slow sensor, which has a pole close to the origin in the $s$-plane, will actually introduce a slow zero into your system's overall response. This can be a source of unexpected overshoot and sluggishness, reminding us once again that in a feedback loop, everything is connected, and the properties of one component can show up in surprising places in the behavior of the whole.

Now that we have wrestled with the principles of non-unity feedback, you might be tempted to think of it as a complication, a pesky deviation from the clean, ideal world of unity feedback. Nothing could be further from the truth! To think that way is like looking at a tree and seeing only the gnarled bark, missing the intricate dance of life it supports. The presence of a sensor with its own dynamics, the $H(s)$ in our loop, is not an inconvenient truth; it is the gateway to understanding how control systems function in the real world. Embracing this reality doesn't break our toolkit; it sharpens it, allowing us to analyze and design systems of far greater sophistication and practical relevance.

Let us embark on a journey to see how these ideas unfold across the landscape of engineering, from tracking stars in the sky to guiding robotic arms with microscopic precision.

When first confronted with a feedback path that is not simply a wire back to the summing junction, one might worry that all the elegant methods we have learned—Routh-Hurwitz stability tests, the root locus method—are now obsolete. It’s a natural fear, but a misplaced one. The beauty of physics and engineering is the search for unifying principles, and we find one here.

The character of any single-loop feedback system, its tendency toward stability or oscillation, is governed entirely by its ​​loop transfer function​​, $L(s) = G(s)H(s)$. This is the transfer function a signal experiences on a full round trip through the loop. The system's characteristic equation is always $1 + G(s)H(s) = 0$. This means that all of our standard analysis tools apply perfectly, so long as we apply them to the combined loop function $L(s)$ instead of just the forward path $G(s)$.

Imagine you are plotting the root locus to see how a system's poles move as you crank up a gain. The rules of the game remain identical: you find the poles and zeros of $L(s)$, and you sketch the paths. The only change is that your starting points are the poles and zeros of both the plant and the sensor combined. Similarly, if you need to determine the range of gains for which a system is stable, you can still construct a Routh array. You simply derive the characteristic polynomial from $1+G(s)H(s)=0$ and proceed as you always have. Nature, it turns out, is remarkably consistent. The logic of feedback doesn't care how the loop is composed, only about its overall character.

Here we come to one of the most subtle and important consequences of non-unity feedback. In a unity feedback system, the signal at the summing junction, $e(t) = r(t) - y(t)$, is the tracking error—the literal difference between what we want and what we have. The controller's entire purpose is to drive this error to zero.

But in a non-unity feedback system, the controller never sees the true output $y(t)$. It only sees the world through the "eyes" of the sensor, $H(s)$. The signal it acts upon is the actuating error, $e_a(t) = r(t) - y_{sensor}(t)$, where $y_{sensor}(t)$ is the output of the sensor. The controller, doing its job diligently, works to make the actuating error zero. It tries to make the sensor's output match the reference signal.

Think of it this way: the sensor $H(s)$ is like a pair of glasses. If the glasses have a constant tint that makes everything appear 25% dimmer (i.e., $H(s) = 0.75$), the controller will adjust the system's output until the world it sees through the glasses matches the brightness of the reference. But to an outside observer without the glasses, the actual output will be brighter than the reference!

This simple idea has profound consequences for steady-state performance. Our familiar error constants for position, velocity, and acceleration—$K_p$, $K_v$, and $K_a$—are now defined by the loop transfer function:

$K_p = \lim_{s \to 0} G(s)H(s)$

$K_v = \lim_{s \to 0} sG(s)H(s)$

$K_a = \lim_{s \to 0} s^2G(s)H(s)$

This is a straightforward extension, as seen in the design of solar-power mirrors and radar tracking systems, where the sensor's gain directly scales the system's error performance.

But the truly fascinating result comes when we look at the tracking error, $e(t) = r(t) - y(t)$. Consider a satellite antenna positioning system, which has an integrator in its forward path ($G(s)$). For a unity feedback system, this Type 1 system would track a step input with zero steady-state error. But now, let's say our position sensor has a DC gain of $K_h \neq 1$. The controller will work until the sensor output equals the reference angle, $y_{sensor,ss} = \theta_{ref}$. Since the sensor's DC behavior is $y_{sensor,ss} = K_h y_{ss}$, the actual steady-state angle of the antenna will be $y_{ss} = \frac{\theta_{ref}}{K_h}$. This leaves a persistent tracking error of:

$e_{ss} = \theta_{ref} - y_{ss} = \theta_{ref} \left(1 - \frac{1}{K_h}\right)$

This is a beautiful and somewhat shocking result! Even with an integrator, we are left with a permanent error that depends entirely on the sensor's calibration. The controller has done its job perfectly based on the information it was given; the discrepancy arises because the information was scaled. This is not a failure of the controller but a fundamental property of the system architecture. It teaches us a vital lesson: to achieve high precision, you must know your sensor as well as you know your plant. The dynamics of the sensor, not just its gain, also play a role, affecting how we must tune our controller gains to meet specific error targets. The distinction between the actuating error that the system minimizes, and the tracking error we care about is at the heart of real-world control engineering.

Once we understand these principles, we can move from simply analyzing systems to designing them with intent. Non-unity feedback isn't a problem to be circumvented; it is a feature to be leveraged.

A powerful illustration of this is ​​cascaded control​​. Many complex systems, like a large antenna positioner, are built with a hierarchy of control loops. An outer loop might control the final angular position, but to do so, it doesn't command the motor directly. Instead, it generates a velocity command as its output. This velocity command becomes the reference signal for a faster, tighter inner loop that controls the motor's speed. This inner velocity loop will have its own controller and a velocity sensor (a tachometer) in its feedback path—a classic non-unity feedback configuration. From the perspective of the outer position loop, this entire inner velocity control system is just one block in its forward path. By analyzing the inner non-unity loop first, we can find its closed-loop transfer function and then use that to design the outer loop. This modular, hierarchical design is the backbone of modern robotics, aerospace, and process control.

This brings us to the ultimate expression of control design: ​​model matching​​. Suppose we have a precise mathematical model for our plant, $G_p(s)$, and for our sensor, $H(s)$. And suppose we have a dream—a perfect, ideal behavior we wish our system to exhibit, represented by a prototype model $M(s)$. Is it possible to design a controller, $G_c(s)$, that forces our real, imperfect system to behave exactly like our ideal model? The answer, remarkably, is often yes. By algebraically solving the closed-loop transfer function equation, we can derive the exact controller transfer function required to achieve this perfect match.

$G_c(s) = \frac{M(s)}{G_p(s)(1 - M(s)H(s))}$

This is a breathtaking idea. It suggests that if we fully understand every component of our system—including the sensor—we can synthesize a "brain" ($G_c(s)$) that perfectly compensates for all the inherent dynamics and delivers exactly the performance we desire. This moves us from trial-and-error tuning to a truly predictive and powerful design methodology.

Our exploration has brought us full circle. We began by acknowledging that the real world is "non-unity." We worried this might complicate our models, but we found instead that it unified them under the banner of the loop transfer function, $L(s) = G(s)H(s)$. We discovered the crucial, subtle difference between what the controller sees and what is actually happening, a difference bridged by the sensor $H(s)$. This led us to understand that perfect tracking requires a perfectly calibrated sensor. Finally, we saw that a complete knowledge of the sensor doesn't just help us account for errors; it empowers us to build more complex, hierarchical systems and even to design controllers that achieve an idealized response. The "imperfection" of the sensor is not a flaw in the model; it is an essential piece of the puzzle, and in its proper place, it reveals a richer, more powerful, and more beautiful picture of the world of control.