Preview Reference Governors:
A Constraint Management Technique
for Systems With Preview Information

Preview control has been a subject of study in the field of control theory for many decades. The main idea behind preview control is to incorporate known or estimated information on the future values of the disturbances or references (i.e., “preview” information) in the computation of the current control command. Such preview may be computed from models or may be available from measurements. For example, in a wind turbine control application, preview information on wind velocity may be available from measurements taken elsewhere in the wind farm. Incorporating this information in the calculation of the control command can result in improved system performance [13].

Common methods for preview control are $H_{\infty}$ preview control [22], LQR preview control [6], and mixed $H_{2}$-$H_{\infty}$ method, just to mention a few (see [2] for a comprehensive review). These methods, however, are not able to enforce pointwise-in-time state and control constraints, which is important to ensure safe and efficient system operation. A preview control method that can, in fact, enforce these constraints is Model Predictive Control (MPC) [1, 18, 3], which is an optimization-based method that can naturally incorporate preview information in the cost function [12]. Some applications of preview-MPC can be found in active suspension [11], swing leg trajectories of biped walking robots [21], and wind turbines [13]. Since MPC is computationally demanding, its applicability has been limited to systems with slow or low-order dynamics, or systems controlled by fast processors [5]. A relatively new constraint management strategy, which alleviates the above computational challenges of MPC, is the Reference Governor, also referred to as the Scalar Reference Governor (SRG) [10, 7, 14, 16, 8, 19]. It is an add-on mechanism that enforces pointwise-in-time state and control constraints by governing, whenever is required, the reference signal of a pre-stabilized closed-loop system (see Figure 1). However, standard SRG uses only the value of the reference signal at the current time and is unable to take preview information into account. This paper fills this gap and presents a novel reference governor-based solution, referred to as the Preview Reference Governor (PRG), to enforce the constraints while incorporating the preview information of the reference and disturbance signals, which yields superior transient performance as compared to SRG.

To explain PRG, we first summarize the main ideas behind SRG. The SRG employs the so-called Maximal Admissible set (MAS) [9], which is defined as the set of all initial conditions and inputs that ensure constraint satisfaction for all times. This set is computed offline. In real-time, SRG computes an optimal $v(t)$ (See Figure 1) to maintain the system state inside the MAS and, thus, enforce the constraints. This is achieved by solving, at every time step, a simple linear program, whose solution can be computed explicitly.

Now reconsider the closed-loop plant $G(z)$ in Figure 1, but assume that the preview information of the reference signal is available. More specifically, ${r(t)},{r(t+1)},\ldots,{r(t+N)}$, are known to the controller at time $t$, where $N$ is the “preview horizon”. We initially assume that $G(z)$ has a single input (we will extend the theory to multi-input systems in Section 7). Similar to SRG, the goal of PRG is to select $v(t)$ as close as possible to $r(t)$ (to ensure that the tracking performance does not suffer) such that the output constraints are satisfied for all times. However, the PRG must take into consideration the preview information of $r(t)$ in order to improve the tracking performance as compared to SRG. To achieve these goals, we first lift $r(t)$ and $v(t)$ from $\mathbb{R}$ to $\mathbb{R}^{(N+1)}$ in order to describe them over the entire preview horizon. Next, the system $G$ is represented based on the lifted input, and a new MAS is calculated based on this new representation. Finally, PRG is formulated as an extension of SRG, where a new optimization problem is solved based on the new MAS and a new update law is used to compute $v(t)$. A high-level block diagram of the PRG is shown in Figure 2, where the availability of the preview information of the reference is explicitly displayed.

As we show in this paper, PRG guarantees constraint satisfaction, recursively feasibility, and closed-loop stability. However, it may calculate conservative inputs under certain conditions, especially for long preview horizons. To overcome this issue and further improve performance, we present an extension of PRG. The extension, which we refer to as Multi-horizon PRG (abbreviated as Multi-$N$ PRG), is based on solving multiple PRGs with different preview horizons and optimally fusing the outputs of the PRGs.

We next consider the case where the system is affected by disturbances, whose preview information is available (in addition to the reference preview). The PRG solution for this case involves formulating a new MAS, wherein the disturbance preview appears explicitly as parameters of the MAS. To guarantee constraint satisfaction, the MAS is robustified to the worst-case realization of disturbances beyond the preview horizon.

In practice, systems are affected by uncertainties in the model as well as the preview information. Therefore, we also consider systems under parametric uncertainties and inaccurate preview information (in either reference or disturbance). We propose a “robust” PRG formulation to robustify the design against these uncertainties.

Finally, we propose two solutions to handle multi-input systems. The first solution comprises the same ideas as in PRG for single-input systems, except that we lift $r(t)$ and $v(t)$ from $\mathbb{R}^{m}$ to $\mathbb{R}^{(N+1)m}$, where $m$ is the number of inputs. However, as will be shown by an example, this solution might lead to a conservative response since a single optimization variable is used to govern all input channels. To overcome this shortcoming, we propose another solution, which combines the Decoupled Reference Governor scheme [15] and PRG theory. Detailed information will be explained in Section 7.

In summary, the original contributions of this work are:

• 1.

  A novel RG-based constraint management scheme with preview capabilities, namely the PRG, which incorporates preview information of the references into the reference governor framework and is more computationally efficient than existing methods such as MPC or Command Governors (CG) [7];

• 2.

  An extension of PRG (Multi-$N$ PRG) to further improve the performance of PRG;

• 3.

  Analysis of recursively feasibility, closed-loop stability, and convergence under constant inputs.

• 4.

  Comparison of the computational footprint and performance of these schemes.

• 5.

  Extensions of PRG to systems with disturbance preview, parametric uncertainties, inaccurate preview information, and multi-input systems.

The following notations are used in this paper. $\mathbb{Z}$ and $\mathbb{Z}_{+}$ denote the set of all integers and non-negative integers, respectively. The identity matrix with dimension $p\times p$ is denoted by $I_{p}$. The variable $t\in\mathbb{Z}_{+}$ is the discrete time. For vectors $x$ and $y$, $x\leq y$ is to be interpreted component-wise. A zero matrix with dimension $p\times q$ is denoted as $0_{p\times q}$.

In this section, the PRG for single-input systems is introduced and analyzed. In addition, PRG is compared with SRG using a numerical example to show that it can significantly improve the closed-loop system performance while enforcing the constraints. An extension of PRG to multi-input systems will be explained in Section 7. As mentioned in the Introduction, PRG is based on lifting the reference (i.e., $r(t)$) and the governed reference (i.e., $v(t)$) from $\mathbb{R}$ to $\mathbb{R}^{(N+1)}$ and representing the system using the lifted input. Based on the new representation, a modified maximal admissible set is characterized and a new formulation of reference governor is proposed, as explained in detail below.

Consider the system shown in Figure 2. Assume $r(t)$, $r(t+1)$, $\ldots$, $r(t+N)$ are available at time $t$, where $r(t)\in\mathbb{R}$ is the current value of the setpoint and $r(t+1),\ldots,r(t+N)\in\mathbb{R}$ are the preview information, and $N\geq 0$ represents the preview horizon. Note that $N=0$ corresponds to the case where no preview information is available. We now define the lifted signals $r_{N}(t)\in\mathbb{R}^{(N+1)}$ (shown in Figure 2) and $v_{N}(t)\in\mathbb{R}^{(N+1)}$, as follows:

Using the lifted signals, $G(z)$ can be equivalently expressed as:

We now describe the Maximal Admissible Set (MAS) for this system. Recall from (3) that in order to characterize MAS in the SRG framework, it is assumed that $v(t)$ is held constant for all time. This will ensure that the optimization problem (8) will always have a feasible solution, namely ${\kappa=0}$. In order to extend these ideas to PRG, we assume that $v(t)$ may vary within the preview horizon, but is held constant beyond the preview horizon. Therefore, the dynamics of $v_{N}(t)$ are chosen to be:

with initial condition $v_{N}(0)=v_{N_{0}}$, where $\bar{A}$ is defined by:

With the new MAS defined, we are now ready to present the PRG formulation. Recall that the SRG computes $v(t)$ using the update law in (7), where $\kappa$ is obtained by solving the linear program (LP) in (8). Note from (7) that $v(t)\in\mathbb{R}$ can be regarded as the internal state of the SRG (i.e., the SRG strategy consists of a single internal state). To extend these ideas to PRG, we introduce $(N+1)$ new states in the formulation, where the state update law is as follows:

where $\kappa$ is the solution of the following linear program:

An explicit algorithm, similar to the one in SRG [15], can be developed to solve this LP efficiently (see Section 5 for details). The PRG solves the above LP at every time step to compute $\kappa$, updates $v_{N}(t)$ using (14), and applies the first element of $v_{N}(t)$ to the system $G$. Note that the variables in the LP in (15) at time step $t$ are $v_{N}(t-1)$, $r_{N}(t)$, and $x(t)$.

Several important properties of the PRG are described in the following proposition.

We now illustrate the PRG using a numerical simulation of a one-link arm robot, shown in Figure 3. A state-space model of the arm is given by:

where $x_{1}\triangleq\theta$, $x_{2}\triangleq\dot{\theta}$ are the states and $\tau$ (i.e., external torque) is the control input. For this example, we assume that both states are measured (if not, an observer can be designed).

In order to design a controller and consequently implement the PRG, the system model (16) is first discretized at $T_{s}=0.01s$. Then, a state-feedback controller with a pre-compensator is applied to ensure that the output, $\theta$, tracks the desired angle, $v$, perfectly, that is: $\tau=66.67v-61.77x_{1}-9.64x_{2}.$ This results in the closed-loop system $G$ shown in Figure 2. We simulate a trajectory-following maneuver, wherein we use the PRG to ensure that the output, $\theta$, remains within $[-45^{\circ},45^{\circ}]$. The preview horizon, $N$, is chosen to be $25$ (i.e., $0.25$ seconds). We assume that the preview information is available from the given pre-set trajectory.

The comparison between the performance of PRG and SRG is shown in Figure 4. As can be seen, $v(t)$ given by PRG is closer to $r(t)$ (less conservative) when $t\in[0.3,0.5]$. This is because when $t=0.3$, the PRG has the future information that the reference would drop down to $0$ in future $25$ time steps so that it allows a larger $v(t)$ than SRG. For the same reason, $v(t)$ given by PRG is less conservative when $t\in[0.7,0.9]$.

Figure 4 shows a limitation of PRG as well. Specifically, it can be seen that when $t\in[0.54,0.64]$, $v(t)$ given by PRG can not reach $r(t)=0$, even though $0$ is an admissible input. To explain the root cause of this behavior, note that when $t=0.54$, the preview information available to the PRG is that $r(t)$ drops down to $-69^{\circ}$ at $t=0.7$ and stays constant afterwards (the increase of $r(t)$ back to 0 at $t=0.9$ is beyond the preview horizon and unavailable to PRG). To enforce the lower constraint for $t>0.7$, the PRG calculates a $\kappa$ smaller than 1. However, since $\kappa$ affects all elements of $v_{N}(t)$ (see (14)), this leads to a $v(t)$ that is different from $r(t)$ when $t\in[0.54,0.64]$, leading to a conservative solution.

Of course, the above limitation of PRG can be addressed by decreasing the preview horizon $N$. However, if $N$ is too short, the tracking performance of the system might not be improved significantly as compared with SRG. In order to have the superior system performance while addressing the above limitation of PRG, we provide an extension of PRG in the following section.

To overcome the limitation of PRG described in the previous section and improve performance, this section introduces the Multi-Horizon Preview Reference Governor (Multi-$N$ PRG). As the name suggests, instead of having a single preview horizon, multiple preview horizons are considered. For each horizon, a MAS is characterized, and multiple PRGs are solved at each time step, one for each MAS. A technical challenge for this approach is that $v_{N}(t)$’s for different preview horizons would have different dimensions and different interpretations. In addition, a practical challenge is that storing multiple MASs may lead to a significant increase in the memory requirements. Our novel solution overcomes these challenge by unifying the $v_{N}$’s so that only one MAS is required, and fusing the PRG solutions in a special way to guarantee constraint satisfaction and recursively feasibility.

To begin, consider the following set of $q$ preview horizons: $N_{1}<N_{2}<\ldots<N_{q}$. Let $O_{\infty}^{N_{i}}$ be defined as in (13), i.e., the MAS of the lifted system with preview horizon $N_{i}$. We first show that there exists a simple relationship between $O_{\infty}^{N_{i}}$, $i=1,\ldots,q-1$, and $O_{\infty}^{N_{q}}$. Recall from (13) and (9) that in order to construct $O_{\infty}^{N_{i}}$, it is assumed that $v(t)$ is held constant beyond the preview horizon (i.e., after ${t=N_{i}}$). Similarly, to construct $O_{\infty}^{N_{q}}$, it is assumed that $v(t)$ is held constant after ${t=N_{q}}$. Thus, $O_{\infty}^{N_{i}}$ and $O_{\infty}^{N_{q}}$ have the following relationship:

where $\Leftrightarrow$ denotes the bidirectional implication and ${v_{N_{i}}(N_{i}+1)}$ is the last element in $v_{N_{i}}$. Therefore, given this relationship, we only need to compute and store $O_{\infty}^{N_{q}}$.

We now introduce the Multi-$N$ PRG, which solves $q$ PRGs at each time step, one for each $N_{i}$. All PRGs use the same MAS, namely $O_{\infty}^{N_{q}}$, as justified above. To provide more details, recall from Section 3 that PRG contains an internal state with an update law given by (14). Similarly, we introduce an internal state, denoted here by $\widetilde{v}\in\mathbb{R}^{(N_{q}+1)}$, for the Multi-$N$ PRG. PRG $i$ in the Multi-$N$ PRG framework assumes the update law:

where $\bar{A}$ is defined the same as (12) but with $N=N_{q}$, and $r_{N_{q}}(t)$ is the lifted version of $r$ at time $t$ (defined as in (9)). The matrix $M_{i}$ is introduced above to force the control inputs beyond the preview horizon $N_{i}$ to be constant (this is to maintain consistency with the fact that PRG $i$ has a preview horizon of length $N_{i}$). The matrix $M_{i}$ that achieves this is:

where $\widetilde{I}_{(N_{q}-N_{i})\times(N_{i}+1)}$ is a matrix with zeros everywhere except the rightmost columns, which are given by $[1,1,\ldots,1]^{T}$. In the update law (17), for PRG $i$, the scalar $\kappa_{i}$ is computed by solving the following LP:

Note that not all PRGs in the Multi-$N$ PRG formulation will have feasible solutions at every time step. If a feasible solution to these PRGs does not exist, $\kappa_{i}$’s for these PRGs are set to be $0$. Note also that even though multiple preview horizons are considered in Multi-$N$ PRG, only $O_{\infty}^{N_{q}}$ is required to be computed and stored offline, implying that if $N_{q}$ for Multi-$N$ PRG is equal to $N$ for PRG, then the memory requirements of the two formulations are the same. We will study the processing requirements in the next section.

The simulation results of Multi-$N$ PRG on the one-link arm robot example are shown in Figure 5. For comparison, the results of the implementation of PRG with $N=25$ is also provided (this is the same as Figure 4). For the sake of illustration, we consider the extreme case where the Multi-$N$ PRG uses all preview horizons between 0 and 25; i.e., $q=26$ and $N_{1}=0$, $N_{2}=1$, …, $N_{26}=25$.

From Figure 5, the outputs for both Multi-$N$ PRG and PRG satisfy the constraints, as expected. However, from the bottom plot of Figure 5, it can be seen that when ${t\in[0.54,0.64]}$, $v(t)$ given by Multi-$N$ PRG reaches $r(t)$ while $v(t)$ computed by PRG is above $r(t)$. The reason for this behavior is that when $t\in[0.54,0.64]$, the PRG corresponding to $N_{1}=0$ computes $\kappa=1$, which leads to $v(t)=r(t)$. Note that the actual performance improvement (as seen on the output plot) is not large for this specific example but it could be large in general.

Next, we will discuss the impact of the value of $q$ in the Multi-$N$ PRG on the system performance. Consider two extreme cases for the sake of illustration: first, $N_{1}$ and $N_{2}$ are chosen to be $0$ and $100$ (i.e., $q=2$); second, $N_{1},\ldots,N_{100}$ are chosen to be all numbers from $0$ to $100$ (i.e., $q=101$). The reason $N_{q}=100$ is selected is that the preview horizon in this case is $1s$ (recall the sample time is $T_{s}=0.01$), which is longer than the variation of the reference in our example, and can clearly show the difference of the system performance between the two cases. The comparison between the two cases implemented on the one-link arm robot example is shown in Figure 6, which demonstrates performance improvements when a larger $q$ is used. Generally, when the preview horizon is longer than the expected variations of the reference, it is better to use the Multi-$N$ PRG formulation with a larger $q$. However, this leads to an increase in the computational burden, which is discussed next.

In this section, we provide a comparison between the computation time of PRG, Multi-$N$ PRG, and standard SRG by simulating the one-link arm robot example with all three methods. Recall that SRG and PRG require the solution to one linear program (LP) at each time step, while Multi-$N$ PRG requires the solutions to $q$ LP’s ($q=26$ for our example). However, we do not use generic LP solvers to solve them. Instead, we use the Algorithm presented in [15] to solve the LPs in SRG and Algorithm 1 below to solve the LPs in PRG. The LPs in Multi-$N$ PRG can be solved using a similar algorithm. The notation in Algorithm 1 is as follows. It is assumed that $O_{\infty}^{N}$ is finitely determined and given by polytopes of the form (5). In addition, $j^{*}$ denotes the number of rows of $H_{x}$, $H_{v}$, and $h$.

We simulate the one-link arm robot example with all three methods, namely SRG, PRG, and Multi-$N$ PRG. All simulations were performed for 150 time steps in Matlab on an Apple Macbook Pro with $1.4$ GHz Intel Core i5 processor and $8$ GB memory. In order to eliminate the effects of background processes running on the computer, each of the above experiments were run $10$ times and the averages are calculated. We calculate the per-timestep averages and maximums of each of the three methods. The results are shown in Table 1. As can be seen, PRG runs two orders of magnitude slower than SRG (because the matrices that arise in the computations are larger). The Multi-$N$ PRG is slower by one order of magnitude (because $q$ PRGs are solved at each time step).

Finally, to provide a comparison of these computation times with those of other existing preview control methods, we simulate the one-link arm robot example with the PRG replaced by a Command Governor (CG). Similar to MPC, a CG solves a Quadratic Program (QP) at each time step to directly optimize over $v(t)$. In addition, similar to MPC, it can incorporate preview information into the cost function. In brief, our CG solves the following QP:

where $Q=Q^{T}>0$. We simulate the system with above CG. The QP above is solved at every time step using explicit Multi-Parametric Quadratic Programming (MPQP), which is introduced in [23]. The computation times of CG are shown in Table 1. As can be seen, CG is one order of magnitude slower than Multi-$N$ PRG. Note that we also implemented online QP for the CG with $N=25$, provided by MPT3 Toolbox in Matlab and Gurobi, and found that the computation times for both cases were longer than that of MPQP.

In this section, PRG is extended to systems with disturbance preview, as well as systems with parametric uncertainties and preview information uncertainties.