Auto-generated Algorithms for Nonlinear Model Predictive Control on ...

Auto-generated Algorithms for Nonlinear Model Predictive Control on Long and on Short Horizons Milan Vukov

Alexander Domahidi

Hans Joachim Ferreau

Abstract— We present a code generation strategy for handling long prediction horizons in the context of real-time nonlinear model predictive control (NMPC). Existing implementations of fast NMPC algorithms use the real-time iteration (RTI) scheme and a condensing technique to reduce the number of optimization variables. Condensing results in a much smaller, but dense quadratic program (QP) to be solved at every time step. While this approach is well suited for short horizons, it leads to unnecessarily long execution times for problem formulations with long horizon. This paper presents a new implementation of auto-generated NMPC code based on a structure exploiting auto-generated QP solver. Utilizing such a QP solver, the condensing step can be avoided and execution times scale linearly with the horizon length instead of cubically. Our simulation results show that this approach significantly decreases the execution time of NMPC with long horizons. For a nonlinear test problem that comprises 9 states and 3 controls on a horizon with 50 time steps, an improvement by a factor of 2 was observed, reducing the execution time for one RTI to below 4 milliseconds on a 3 GHz CPU.

I. INTRODUCTION Model predictive control (MPC) has been originally designed and used for control of large-scale processes, typically in the chemical and petroleum industry. Slow dynamics of those systems allowed large control intervals measured in tens of seconds or even hours, leaving enough time to compute a solution to the underlying optimization problem. However, progress in the area of optimization algorithms and computational hardware in the last two decades have extended the applicability of numerical optimization on embedded platforms. These developments made MPC suitable for control of fast dynamical systems with time constants in micro- and millisecond range. Milan Vukov and Moritz Diehl are with the Department of Electrical Engineering, KU Leuven, Kasteelpark Arenberg 10, 3001 Leuven, Belgium. Alexander Domahidi and Manfred Morari are with the Automatic Control Laboratory, Department of Information Technology and Electrical Engineering, ETH Zurich, 8092 Zurich, Switzerland. Hans Joachim Ferreau is with the ABB Corporate Research, BadenD¨attwil, Switzerland. Contact: [email protected] This research was supported by Research Council KUL: PFV/10/002 Optimization in Engineering Center OPTEC, GOA/10/09 MaNet and GOA/10/11 Global real- time optimal control of autonomous robots and mechatronic systems. Flemish Government: IOF/KP/SCORES4CHEM, FWO: PhD/postdoc grants and projects: G.0320.08 (convex MPC), G.0377.09 (Mechatronics MPC); IWT: PhD Grants, projects: SBO LeCoPro; Belgian Federal Science Policy Office: IUAP P7 (DYSCO, Dynamical systems, control and optimization, 2012-2017); EU: FP7-EMBOCON (ICT248940), FP7-SADCO ( MC ITN-264735), ERC ST HIGHWIND (259 166), Eurostars SMART, ACCM. The authors would like to thank Janick Frasch and Timon Achtnich for helpful discussions during the preparation of this paper.

Manfred Morari

Moritz Diehl

Nonlinear model predictive control (NMPC) allows one to apply MPC to nonlinear dynamical systems [3], [4]. The continuation/GMRES method [19], the advanced step NMPC controller [28] and the real-time iteration (RTI) scheme [7], [8] represent efficient algorithms for fast NMPC. The reader is referred to [9] for a more detailed overview. Automatic code generation for convex optimization solvers became very popular recently. The basic idea of code generation is to exploit the fact that all problem dimensions and structure is known a priori. This allows one to generate highly customized and fast solver code, which then solves instances of a specific problem. The code generation framework CVXGEN [17] was the first implementation that allowed one to export tailored interior-point (IP) solvers that can solve quadratic programs (QPs) very fast on embedded platforms. Following the observation that linear MPC problems fall into the class of multistage problems with particular structure [11], FORCES has been designed to overcome the limitations of CVXGEN in terms of problem size. The FORCES code generation framework [10] exports primaldual interior point codes. In a similar fashion, nonlinear MPC (NMPC) relevant dimensions are also known before deployment of a controller and highly efficient code can be generated to speed up computations. To our knowledge, the existing implementations of NMPC code generators are AutoGenU [23] and the ACADO Code Generation tool [15]. The ACADO Code Generation tool exports efficient self-contained C-code that implements the RTI scheme. The algorithm implements an sequential quadratic programming (SQP) framework and consists of simulation and linearization of the nonlinear system, and solution of a convex subproblem – a QP. The RTI scheme [8] performs a single SQP iteration per sampling instant in order to quickly deliver an approximate solution to the optimization problem. An experimental verification of the exported NMPC code is presented in [25], showing execution times below 1.1 milliseconds per RTI step for a nontrivial dynamic model. The original implementation of the code generator for nonlinear MPC within the ACADO toolkit utilizes the embedded version of the QP solver qpOASES [1]. The QP solver is based on an (online) active set strategy [12] and employs dense linear algebra routines. To obtain feedback times in the milliseconds range, a technique called condensing [6] is applied, which significantly reduces the number of optimization variables in the QP. However, both the condensing procedure and an active-set QP solver have cubic complexity in number of prediction intervals, leading to prohibitively

long execution times when long prediction horizons are needed. In this paper we present an extension of the ACADO Code Generation tool for NMPC that can efficiently handle long prediction horizons. In particular, we present a variant of an auto-generated NMPC that is utilizing the structure exploiting QP solver FORCES [11], [10]. Employing FORCES bypasses usage of the condensing procedure, thus saves a significant amount of computational time for long prediction horizons. The new implementation of the NMPC is tested against the original, condensing based, NMPC on a scalable example – a chain of masses connected with springs. The purpose of this paper is to explore at which horizon length the cubic growth will make condensing non-competitive compared with NMPC utilizing sparse QP solver. The paper is organized as follows. In Section II, we introduce the problem formulation of the nonlinear MPC problem, and give the concept of the real-time iteration (RTI) scheme and background on dense vs. sparse QP solvers. Section III describes the ACADO Code Generation tool and the extension to generating code that utilizes sparse QP solvers. We give a numerical example showing the computational benefits for long horizons with the structure exploiting QP solver FORCES in Section IV. Section V concludes the paper.

The typical choice for NMPC is to use piecewise constant parametrization of controls, resulting in N control variables uk , k = 0, . . . , N − 1. In the context of multiple shooting, the state trajectory is computed independently on each subinterval [tk ,tk+1 ]. For that purpose, additional variables sk are introduced to serve as initial values: x˙k (t) = f (xk (t), uk ),

sk+1 = Fk (sk , uk ),

2

min u, s

 kx(t) − xref (t)k2Q + ku(t) − uref (t)k2R dt

+ kx(t0 + T ) − xref (t0 + T )k2P s.t.

(1a)

x(t0 ) = xˆ0 ,

(1b)

x(t) ˙ = f (x(t), u(t)),

(1c)

u ≤ u(t) ≤ u,

(1d)

x ≤ x(t) ≤ x,

for all t ∈ [t0 ,t0 + T ].

k = 0, . . . , N − 1,

(1e)

Within this formulation t0 denotes the current time, T denotes the length of the prediction horizon, x ∈ Rnx denotes the state vector, u ∈ Rnu denotes the control vector. Vectors xref ∈ Rnx and uref ∈ Rnu denote time-varying state and control references, respectively. The weighted least squares objective in (1a) uses weighting matrices Q, P  0 and R  0. Variable xˆ0 denotes the (measurement of the) current state. Function f (x, u) describes system dynamics with ordinary differential equations (ODEs). The bounds on controls and states are given in (1d) and (1e), respectively. A. Direct Multiple Shooting Discretization We use the direct multiple shooting technique [6] to transform the infinite dimensional OCP (1) into a nonlinear program (NLP). The time horizon [t0 ,t0 + T ] is partitioned on a finite grid into N subintervals [tk ,tk+1 ], k = 0, . . . , N − 1.

(3)

where Fk represents the solution of the initial value problem (IVP) (2) at time t = tk+1 . The objective and path constraints are discretized at the same grid as the states and controls. The NLP that comes as a result of the multiple shooting discretization reads:

Z t0 +T  1 t0

(2)

Furthermore, in order to ensure continuity of the optimal state trajectory on the whole horizon matching constraints are added to the NLP:

We consider the following optimal control problem (OCP):

x(·), u(·)

t ∈ [tk ,tk+1 ].

 1 N−1  ref 2 ref 2 ks − x k + ku − u k ∑ k k Q k k R + ksN − xNref k2P 2 k=0 (4a)

s.t. s0 = xˆ0 ,

II. REAL-TIME ITERATIONS FOR NONLINEAR MPC

min

xk (tk ) = sk ,

(4b)

sk+1 = F(tk+1 ;tk , sk , uk ),

k = 0, . . . N − 1,

(4c)

u ≤ uk ≤ u,

k = 0, . . . N − 1,

(4d)

x ≤ sk ≤ x,

k = 1, . . . N,

(4e)

B. Generalized Gauss-Newton Method and Real-Time Iterations Since the objective (4a) is of least squares form, the NLP (4) can be solved using a generalized Gauss-Newton method [5]. For sake of brevity, the optimization variables of the NLP are summarized in a single column vector w = [s00 u00 . . . s0N ]0 and we will refer to w as a current linearization point. Linearizing the NLP around w, a sequential quadratic programming (SQP) iteration is performed, and the NLP variables are updated as follows w+ = w + ∆w∗ ,

(5)

where ∆w∗ denotes the solution of the following QP: min ∆u, ∆s

s.t.

     0  s  1 N−1 ∆sk 0 Q ∆sk ∆sk gk + ∑ ∆uk R ∆uk ∆uk guk 2 k=0 1 + ∆xN0 P∆xN + ∆xN0 gxN 2 ∆s0 = xˆ0 − s0 ,

(6a) (6b)

∆sk+1 = ak + Ak ∆sk + Bk ∆uk , k = 0, . . . N − 1, (6c) u − uk ≤ ∆uk ≤ u − uk , x − sk ≤ ∆sk ≤ x − sk ,

k = 0, . . . N − 1, k = 1, . . . N,

(6d) (6e)

Condensing based real-time iterations for NMPC

with ∂ Fk ∂ Fk ak = Fk (sk , uk ) − sk+1 , Ak = (sk , uk ), Bk = (sk , uk ), ∂ sk ∂ uk (7a) gsk = Q(sk − xkref ), guk = R(uk − uref k ).

(7b)

The RTI scheme [8] uses the control and state variables of the previous optimization run, possibly after a shift, as new linearization point, and performs only one Newton-type iteration per sampling instant. Due to the fact that the initial value enters the problem linearly, it can be shown to deliver a generalized tangential predictor to perturbations, and nominal convergence of the resulting NMPC loop can be proven. We refer to [9] and the references therein for a detailed survey on the RTI and other algorithms for nonlinear MPC. C. Condensing procedure The goal of the condensing procedure [6] is to reduce the number of optimization variables in the QP (6). The system of linearized dynamic equations (6c) can be regarded as an affine time variant dynamic system with steps ∆sk . Assuming ∆s0 and the variables ∆w1 = (∆u0 , . . . , ∆uN−1 ) are known, the variables ∆w2 = (∆s1 , . . . , ∆sN ) can be obtained by a forward simulation. Thus, the resulting map is also affine: ∆w2 = d +C∆s0 + E∆w1 ,

(8)

Here, matrices C ∈ R(N·nx )×nx and E ∈ R(N·nx )×(N·nu ) have a special block structure:     E0,0 C0   E0,1 E1,1  C1   , E =  C= ,  . . ..  ...  ..   .. . CN−1 E0,N−1 · · · EN−1,N−1 (9) where the corresponding blocks are computed as: Ck = Ak · . . . · A0 , k = 0, . . . , N − 1, Ek,m = Ak Ek−1,m , k = 1, . . . , N − 1, m = 0, . . . , k − 1, Ek,k = Bk , k = 0, . . . , N − 1. (10) Vector d can be computed by a forward simulation of the affine dynamic system (6c) with ∆s0 = 0 and ∆w1 = 0. This yields a recursion: d0 = a0 ,

dk = ak + Ak dk−1 ,

k = 1, . . . , N − 1

(11)

Applying the condensing procedure to the original sparse QP (6), an equivalent, condensed, QP is obtained as: 1 0 ∆w Hc ∆w1 + ∆w01 gc (12a) min ∆w1 2 1 s.t. w1 − w1 ≤ ∆w1 ≤ w1 − w1 (12b) w2 − w˜ 2 ≤ E∆w1 ≤ w2 − w˜ 2

(12c)

with w˜ 2 = w2 + d + C∆s0 . The Hessian and the linear term of the condensed QP are obtained as: Hc = E 0 QE + R,

(13a)

gc = E 0 Qd + E 0 gs + gu + E 0 QC∆s0 ,

(13b)

Initialization: Initialize sk , k = 0, . . . , N and uk , k = 0, . . . , N − 1. Repeat online: 1 Preparation step 1.1 Solve IVPs (2) and generate sensitivities Ak and Bk . 1.2 Evaluate objective. 1.3 Condense large QP (6) into a smaller dense QP (12). 1.4 Wait for a new state feedback xˆ0 . 2 Feedback step 2.1 Use the state feedback to compute the linear term of the dense QP and bounds on affine constraints. 2.2 Solve the dense QP (12). 2.3 Send the first control, u+ 0 , to the process.

Fig. 1: A simplified description of the classical condensing based RTI scheme for NMPC. where Q ∈ R(N·nx )×(N·nx ) and R ∈ R(N·nu )×(N·nu ) are block diagonal matrices with matrices Q and R on the corresponding diagonals. Analyzing (12) and (13), it can be easily concluded that all quantities except the linear term gc and two terms in the lower and upper affine constraint bounds can be precomputed – in the RTI this is called as the preparation phase. As soon as the current state xˆ0 becomes available, the linear term and lower and upper bounds of the affine constraints are computed and the QP (12) is solved. This is called the feedback phase. Once the QP is solved, the control vector ∗ on the first shooting interval is updated, u+ 0 = u0 + ∆u0 , and immediately sent to the process. Afterwards, we can apply the so-called expansion step to obtain all variables from the original QP (6). The control variables are updated ∗ with u+ k = uk + ∆uk , k = 1, . . . , N − 1, while variables sk are updated using (8): ∗ w+ 2 = w2 + d +C∆s0 + E∆w1 .

(14)

The classical condensing based RTI scheme is shown on Fig. 1. The main computational bottleneck of the condensing technique is the computation of the condensed Hessian Hc . In particular, O(N 3 ) complexity results from the multiplication of E 0 with QE. A naive approach would lead to exactly N 3 block multiplications. However, significant savings can be obtained by taking into account that matrix E is lower block triangular and Q is block diagonal, along with the fact that we need to calculate only upper (or lower) triangular blocks of the reduced Hessian Hc . This approach results in N(N + 1)(N + 2)/6 block multiplications, each of runtime complexity of n2u nx floating point operations (flops1 ). In other words, more than 75% block multiplications can be saved for N > 7 compared to the naive approach. On the other hand, condensing technique greatly reduces the number of optimization variables, from (N + 1)nx + Nnu to Nnu . This allows us to solve (12) with an efficient 1 flops - addition, multiplication or fused multiply-accumulate operations of two floating point numbers

dense linear algebra QP solver, such as qpOASES [1], and significantly reduce the feedback delays. The condensing technique is known to perform well for relatively short horizons. D. Solution of the sparse problem The second way of solving (6) is to keep and optimize all variables of the original problems: ∆s and ∆u, i.e. avoid the aforementioned condensing procedure. This leaves far more variables in the problem. However, compared to the the condensed, dense QP (12), the problem described in (6) is highly structured. This structure can be exploited to yield
a computational complexity of O N(n3x + n3u ) , significantly reducing the execution time of one real-time iteration for long prediction horizons compared to the condensing based approach. The exploration of this banded structure in the solution of nonlinear control problems was first proposed in [24] and for linear MPC in [22]. There are currently three freely available fast embedded QP solvers that can exploit the structure of (6): an efficient prototype implementation of a primal-barrier interior point method named fastMPC [26] and two auto-generated solvers that implement a primal-dual interior point method: CVXGEN [18], [16] and FORCES [11], [10]. CVXGEN is optimized for small problems and provides C-code that can be executed in orders of milliseconds or even microseconds, while FORCES has about the same speed but supports problems of arbitrary size. In this paper, we focus on employing FORCES, which supports more general convex multi-stage problems of the form min z

1 N−1 0 ∑ zk HF,k zk + z0k gF,k 2 k=0

(15a)

s.t. CF,k zk + DF,k+1 zk+1 = cF,k , k = 0, . . . , N − 1, (15b) hF,k (zk ) ≤ 0,

k = 0, . . . , N.

(15c)

with N + 1 stage variables zk , coupling equality constraints (15b) and convex inequality constraints hF,k . The problem (15) can be solved efficiently by exploiting the inherent problem structure. In particular, the Hessian in (15) is block-diagonal, and together with (15b), this introduces a block-banded structure in the reduced coefficient matrix of the linearized Karush-Kun-Tucker (KKT) system. Solving this system to obtain a search direction is the bottleneck of interior point methods, and can be done as suggested in [26], [11], [22], [24] quickly by exploiting the blockbanded structure. Moreover, the FORCES solver is able to exploit certain special cases of MPC, for example how to efficiently deal with diagonal Hessian block HF,k and take advantage of the fact that (6) has only box constraints. More general constraints such as quadratic constraints are supported as well, but not considered in this paper. III. ACADO CODE GENERATION TOOL The ACADO Code Generation tool is part of the opensource software package ACADO Toolkit for automatic

control and dynamic optimization [14]. The tool implements the algorithmic ideas based on the real-time iteration scheme. The user interface allows one to specify nonlinear dynamic model equations as well as objective and constraint functions. The original implementation of code-generator allowed for the export of generalized Gauss-Newton method for nonlinear MPC [15], and was followed up with extensions that made it possible to specify and export a solver for moving horizon estimation (MHE) [13]. The tool exploits problem structure and dimensions together with sparsity patterns to remove all unnecessary computations and remove the need for dynamic memory allocation. More details on the ACADO Code Generation tool can be found in [2]. More recent extensions of the ACADO Code Generation tool include support for implicit integrators for ODEs and differential algebraic equations (DAEs) [21], [20]. Those extensions allow handling of more challenging stiff dynamic models where usage of explicit integrators would require far more integration steps per prediction interval. This would directly lead to prohibitively long execution times. Both the original implementation of auto-generated MPC and the later MHE extension implement a condensing procedure in order to solve a smaller-scale QP by means of a dense linear algebra QP solver. Cubic complexities of the condensing procedure and active-set based QP solver reduce the applicability of the considered approach for OCPs with long horizons. The latest extension of the tool that is presented in this paper makes it possible to solve long horizon OCPs with interior point based solver FORCES inside ACADO. This way the expensive O(N 3 ) condensing procedure is avoided, and in fact exchanged for O(N) complexity coming from structure-exploiting IP based QP solver. From user point of view, only two options have to be changed in order to generate an MPC solver that is internally using FORCES to solve the QP (6). The ACADO Code Generation tool generates selfcontained ANSI-C compliant code, which can be deployed on any platform supporting the standard C library. The same holds for the auto-generated FORCES based QP solver. The qpOASES solver is provided in form of self-contained ANSI C++ code, thus creates slightly more dependencies. Branching in the exported code is minimized leading to improved code locality, thus faster execution times. Furthermore, heuristics have been implemented to unroll for-loops whenever possible to increase efficiency of the compiled code. IV. NUMERICAL SIMULATIONS In order to test both NMPC implementations we have chosen a chain of masses connected with springs [27], illustrated in Fig. 2. The dynamics of this system is nonlinear due to nonlinear spring forces. Furthermore, this model is easily scalable, meaning that the problem complexity can be increased by adding additional masses to the chain. The goal of each controller is to move back the chain from its

TABLE I: Relevant dimensions of the NMPC controller applied to the chain of masses; nx = 3(2M + 1), nu = 3.

Fixed end

1

Approach

QP variables

QP bounds

Aff. constraints

Condensed Sparse

Nnu Nnu + (N + 1)nx

Nnu Nnu + (N + 1)M

NM 0

0.5 0 −0.5

z [m]

−1 −1.5 −2 −2.5 −3

0 0.2

−3.5

0.4

−4

0.6 0

0.2

0.4

0.8

0.6

0.8

1

1

x [m]

y [m]

Fig. 2: A chain of masses connected with springs. The blue chain denotes equilibrium state, the red chain illustrates disturbed state. The green patch represents a wall and black dot the fixed point of the chain.

disturbed to its equilibrium state, respecting upper and lower bounds on both states and input variables. A. Simulation model We consider a chain with M balls of equal mass m that are connected with springs. All springs have equal rest length L and spring constant D. At both ends additional identical springs are attached. One end of the chain is attached to a fixed point, while the velocity of the other end u = (ux , uy , uz ) can be controlled. The center of each ball is represented by a 3-dimensional coordinate pi = (px,i , py,i , pz,i ). For the chain comprising M balls, an ODE that describes model dynamics has nx = (2M + 1) · 3 states and nu = 3 controls. In the rest of the paper it is assumed that all states can be measured. For all details specific to the model we refer to [27]. B. Simulation scenario The continuous ODE model is parametrized by the multiple shooting technique using intervals of Ts = 200 ms. In order to reliably integrate the model we chose implicit GaussLegendre integrator of order four, with one integration step per shooting interval. The constraints that the controller must respect are defined as follows. There are simple input bounds −1 m/s ≤ u j ≤ 1 m/s,

j ∈ {x, y, z},

and there is a set of tight state bounds imposed by a wall next to the equilibrium plane (see Fig. 2): −0.01 m ≤ py,i ,

i = 0, . . . , M − 1.

In other words, the chain must not hit the wall during the simulation. Compared to the simulation settings in [27], the wall is placed at a closer distance to the equilibrium plane. This makes the problem even harder to solve, and this was a design decision made in order to increase the number of active constraints during the simulations. Note that in case of condensing based NMPC state bounds are transformed to

affine inequalities, in form of (12c). Relevant controller QP dimensions are summarized in Tables I. All simulations are performed on a 3GHz Intel Q9650 based desktop computer, running the 64-bit version of Ubuntu Linux 12.04. All codes are compiled with the Intel 13.0.1 compiler, using the flags: -O3 -xHost. Execution times are measured with the Linux function clock_gettime(), which yields resolution in the nanosecond range. C. Results Simulations are performed for three different variants of chain mass problem, namely for M = 1, 2, 3. For each dynamic system ten controllers are tested, for different horizon lengths N in the range from 5 to 50. Simulation results are presented in Fig. 3. All plots show the maximum run-times for both types of controllers. Simulation results show that for a test problem with 9 states, 3 control inputs and 50 prediction intervals, the execution time can be reduced by a factor greater than 2 when using the new extension of the auto-generated NMPC. Starting at horizon N = 5 and M = 1 we can observe that condensing based approach is very cheap. The feedback time is very short because a very small QP is solved, comprising only 15 variables. On the other hand, the runtime of the sparse QP solver is more expensive due to its internal factorizations which are of O(n3x + n3u ) complexity; in this case number of optimization variables is more than four times larger that in the condensing based NMPC. Increasing the number of prediction intervals N, runtime of the condensing based NMPC scales with N 3 , while the full-space NMPC scales linearly in N, as expected. For a fixed number number of prediction intervals N, in the case of condensing based NMPC number of optimization variables is Nnu , i.e. independent of the number of states nx . However, an increase of the number of states nx leads to an increased number of affine constraints (12c) – MN. This directly makes an NMPC problem harder to solve, i.e. requires more working set recalculations when using an active set based QP solver, resulting in longer runtimes. Increase of number of intervals N directly leads to a cubic increase in the runtime of one RTI, as can be observed on Fig. 3. For a fixed number of controls nu and fixed horizon length N, run-time of the interior point QP solver is proportional to the n3x . For shorter horizons, this makes IP based solver less favorable. In particular, as shown in Fig. 3, the condensing based solver is competitive until horizon lengths of 26, 40, and 50, for M = 1, 2, and 3, respectively. However, linear complexity in N makes the IP based solver superior for

10

RTI execution time [ms]

NMPC with condensing NMPC with FORCES 8

6

4

2

0

10

20

30 Horizon length

40

50

R EFERENCES

(a) Results obtained for chain with one mass 20

RTI execution time [ms]

NMPC with condensing NMPC with FORCES 15

10

5

0

10

20

30 Horizon length

40

50

(b) Results obtained for chain with two masses 30 NMPC with condensing NMPC with FORCES

RTI execution time [ms]

25 20 15 10 5 0

10

20

30 Horizon length

40

V. CONCLUSIONS AND OUTLOOK This paper presents the most recent extension of the ACADO toolkit Code Generation tool to efficiently handle small to medium scale NMPC problems with long horizons in the millisecond range using the structure exploiting interior point based solver FORCES. The exported code is ANSI C/C++ compatible and can be deployed on arbitrary embedded platforms. The obtained results reflect the benefits of using condensing for short horizons and FORCES for long horizons, making the ACADO code generation tool able to solve a wide range of optimal control problems efficiently. Future work will include extensions to support more general OCP formulations, as well as support for DAEs.

50

(c) Results obtained for chain with three masses

Fig. 3: Maximum execution times of condensing based NMPC () and NMPC with sparse QP solver (F); full lines and dashed lines denote cubic and linear fits, respectively. Integration times, which are identical for both approaches, are denoted with dotted lines.

longer horizons where the complexity of the condensing based NMPC is dominated by the cubic terms in N.

[1] qpOASES Homepage. http://www.qpOASES.org, 2007–2013. [2] ACADO Toolkit Homepage. http://www.acadotoolkit.org, 2009–2013. [3] F. Allg¨ower and A. Zheng. Nonlinear Predictive Control, volume 26 of Progress in Systems Theory. Birkh¨auser, Basel Boston Berlin, 2000. [4] L.T. Biegler and J.B Rawlings. Optimization approaches to nonlinear model predictive control. In W.H. Ray and Y. Arkun, editors, Proc. 4th International Conference on Chemical Process Control - CPC IV, pages 543–571. AIChE, CACHE, 1991. [5] H.G. Bock. Recent advances in parameter identification techniques for ODE. In P. Deuflhard and E. Hairer, editors, Numerical Treatment of Inverse Problems in Differential and Integral Equations. Birkh¨auser, Boston, 1983. [6] H.G. Bock and K.J. Plitt. A multiple shooting algorithm for direct solution of optimal control problems. In Proceedings 9th IFAC World Congress Budapest, pages 243–247. Pergamon Press, 1984. [7] M. Diehl. Real-Time Optimization for Large Scale Nonlinear Processes. PhD thesis, Universit¨at Heidelberg, 2001. http://www.ub.uniheidelberg.de/archiv/1659/. [8] M. Diehl, H.G. Bock, J.P. Schl¨oder, R. Findeisen, Z. Nagy, and F. Allg¨ower. Real-time optimization and Nonlinear Model Predictive Control of Processes governed by differential-algebraic equations. J. Proc. Contr., 12(4):577–585, 2002. [9] M. Diehl, H. J. Ferreau, and N. Haverbeke. Nonlinear model predictive control, volume 384 of Lecture Notes in Control and Information Sciences, chapter Efficient Numerical Methods for Nonlinear MPC and Moving Horizon Estimation, pages 391–417. Springer, 2009. [10] A. Domahidi. FORCES website. http://forces.ethz.ch, 2011 – 2013. [11] A. Domahidi, A. Zgraggen, M.N. Zeilinger, M. Morari, and C.N. Jones. Efficient interior point methods for multistage problems arising in receding horizon control. In IEEE Conference on Decision and Control (CDC), pages 668 – 674, Maui, HI, USA, December 2012. [12] H. J. Ferreau, H. G. Bock, and M. Diehl. An online active set strategy to overcome the limitations of explicit MPC. International Journal of Robust and Nonlinear Control, 18(8):816–830, 2008. [13] H.J. Ferreau, T. Kraus, M. Vukov, W. Saeys, and M. Diehl. Highspeed moving horizon estimation based on automatic code generation. In Proceedings of the 51th IEEE Conference on Decision and Control (CDC 2012), Hawaii, 2012. (accepted). [14] B. Houska, H.J. Ferreau, and M. Diehl. ACADO Toolkit – An Open Source Framework for Automatic Control and Dynamic Optimization. Optimal Control Applications and Methods, 32(3):298–312, 2011. [15] B. Houska, H.J. Ferreau, and M. Diehl. An Auto-Generated Real-Time Iteration Algorithm for Nonlinear MPC in the Microsecond Range. Automatica, 47(10):2279–2285, 2011. [16] J. Mattingley and S. Boyd. CVXGEN webage. http://cvxgen.com, 2008–2011. [17] J. Mattingley and S. Boyd. Convex Optimization in Signal Processing and Communications, chapter Automatic Code Generation for RealTime Convex Optimization. Cambridge University Press, 2009. [18] J. Mattingley, Y. Wang, and Stephen Boyd. Code generation for receding horizon control. In Proceedings of the IEEE International Symposium on Computer-Aided Control System Design, Yokohama, Japan, 2010. [19] T. Ohtsuka. A Continuation/GMRES Method for Fast Computation of Nonlinear Receding Horizon Control. Automatica, 40(4):563–574, 2004.

[20] R. Quirynen, S. Gros, and M. Diehl. Fast auto generated ACADO integrators and application to MHE with multi-rate measurements. In Proceedings of the European Control Conference, 2013. [21] R. Quirynen, M. Vukov, and M. Diehl. Auto Generation of Implicit Integrators for Embedded NMPC with Microsecond Sampling Times. In Mircea Lazar and Frank Allgower, editors, Proceedings of the 4th IFAC Nonlinear Model Predictive Control Conference, Noordwijkerhout, The Netherlands, volume 4, 2012. [22] C.V. Rao, S.J. Wright, and J.B. Rawlings. Application of InteriorPoint Methods to Model Predictive Control. Journal of Optimization Theory and Applications, 99:723–757, 1998. [23] H. Seguchi and T. Ohtsuka. Nonlinear Receding Horizon Control of an Underactuated Hovercraft. International Journal of Robust and Nonlinear Control, 13(3–4):381–398, 2003. [24] M.C. Steinbach. Fast recursive SQP methods for large-scale optimal control problems. PhD thesis, Universit¨at Heidelberg, IWR, 1995. [25] M. Vukov, W. Van Loock, B. Houska, H.J. Ferreau, J. Swevers, and M. Diehl. Experimental Validation of Nonlinear MPC on an Overhead Crane using Automatic Code Generation. In The 2012 American Control Conference, Montreal, Canada., 2012. [26] Y. Wang and S. Boyd. Fast model predictive control using online optimization. IEEE Transactions on Control Systems Technology, 18(2):267–278, 2010. [27] L. Wirsching, H. G. Bock, and M. Diehl. Fast NMPC of a chain of masses connected by springs. In Proceedings of the IEEE International Conference on Control Applications, Munich, pages 591–596, 2006. [28] V. M. Zavala and L.T. Biegler. The Advanced Step NMPC Controller: Optimality, Stability and Robustness. Automatica, 45:86–93, 2009.