Lifted Explicit Interpolating Control for Low-End Embedded Microcontrollers: An Active Vibration Control Case Study

Lifted Explicit Interpolating Control for Low-End Embedded Microcontrollers: An Active Vibration Control Case Study ⋆ Martin Gulan ∗Gergely Tak´acs ∗∗ Sorin Olaru ∗∗∗ ∗Slovak University of Technology, Faculty of Mechanical Engineering, N´amestie slobody 17, 812 31 Bratislava, Slovakia (e-mail: [email protected]) ∗∗ Garrett Motion, Z´aborsk´e 515, 082 53 Z´aborsk´e, Slovakia (e-mail: [email protected]) ∗∗∗ Universit´e Paris-Saclay, CNRS, CentraleSup´elec, Laboratory of Signals and Systems, 3 rue Joliot Curie, 911 90 Gif-sur-Yvette, France (e-mail: [email protected]) Abstract: Motivated by contributing to the use of advanced, model-based control in embedded applications using extremely limited computing hardware, in this paper we present a constrained control alternative to linear model predictive control (MPC). In the proposed two-layer scheme, we revisit the interpolation-based control framework, and show that the structure of its explicit solution can be conveniently exploited by the convex lifting concept to generate low-complexity controllers. Their performance, fast evaluation time and low memory footprint are demonstrated in an active vibration control case study, where deployed on an 8-bit ATtiny85 microcontroller. Keywords: convex lifting, interpolating control, microcontroller, active vibration control 1. INTRODUCTION Thanks to the constantly dropping price of hardware and increased performance, as well as to the ongoing design of new computationally efficient MPC methods, applications with high sampling rates are now well within the realm of practical implementation possibilities. The evolution of efficient optimization-based but recently also learning-based methods has been followed by the natural need to implement them in so-called embedded devices; see e.g. Ferreau et al. (2017); Gulan et al. (2019); Karg and Lucia (2021). The largest category of embedded devices is represented by the well-known microcontroller unit (MCU), that integrates the computer system on a chip. The most powerful MCUs nowadays may offer up to hundreds of MHz in clock speed using 32-bit architectures, several MB of flash memory and a floating point unit; rendering the implementation of efficient MPC virtually trouble-free. Mass-produced simple devices, however, rely on the use of much humbler hardware with harshly limited computing power and memory; making the 8-bit architecture nowadays more abundant than ever. There is indeed technically no reason why the mass-produced, cheap, everyday products and devices should not benefit from advanced control techniques such as MPC. However, as demonstrated also in this study, even explicit linear MPC controllers quickly become infeasible when aiming for deployment on minimalist 8-bit MCUs. ⋆The authors gratefully acknowledge the support under the grants APVV-18-002, APVV-22-0436, and 027STU-4-2024. This paper was funded by the European Union under Horizon Europe Grant Agreement number 101079342 (Fostering Opportunities Towards Slovak Excellence in Advanced Control for Smart Industries). A particularly interesting alternative to computationallyintensive control schemes such as MPC was proposed by Nguyen et al. (2013), and is based on convex interpolation between the vertex control law, adopted from Gutman and Cwikel (1986), and a local unconstrained control law. This so-called improved vertex control, or simply interpolating control, based on linear programming provides a straightforward suboptimal solution, while guaranteeing recursive feasibility, robust asymptotic stability and local optimality near the origin.Moreover, as shown in Nguyen et al. (2016), the interpolating control admits an explicit solution with a piecewise affine control law allowing to shift the optimization burden offline. Another interesting concept, shown to have several applications in constrained control design (see e.g. Gulan et al. (2017, 2019, 2020); Ioan et al. (2020)) is the convex lifting (Nguyen et al., 2018). In particular, as presented in Gulan et al. (2017), it enables a memoryand time-efficient implementation of explicit MPC (EMPC) controllers. In this paper, recalling our above co-/authored works, we show and practically demonstrate for a nominal state feedback case, how the concepts of convex lifting and explicit interpolating control(EIC)canbe synergically combined to yield lightweight controllers embeddable on an 8-bit MCU. 2. LIFTED EXPLICIT INTERPOLATING CONTROL In this section we revisit essential features of the two main ingredients of the proposed approach—explicit solution to the interpolating control problem and its efficient implementation via convex lifting. For any details we refer the interested reader to our previous works cited hereinafter. 2.1 Explicit interpolating control via linear programming Consider the problem of regulating to the origin the following time-invariant linear discrete-time system: x(k+ 1) = Ax(k)+Bu(k),(1) where x(k)∈Rnxand u(k)∈Rnuare respectively, the measurable state vector and the input vector. We assume that the pair (A,B) is stabilizable and both x(k) and u(k) are subject to polytopic constraints: x(k)∈X,X={x∈Rnx:Fxx≤gx} u(k)∈ U,U={u∈Rnu:Fuu≤gu}∀k≥0.(2) Let us define a linear controller K∈Rnu×nx, such that, u(k) = Kx(k) (3) asymptotically stabilizes the system (1). Synthesis of interpolating control relies on two sets, namely the maximal invariant set, Ω={x∈Rnx:Fox≤go},(4) and the N-step controlled invariant set, PN={x∈Rnx:FNx≤gN},(5) such that all x∈PNcan be steered into Ω in no more than Nsteps; see e.g. Borrelli et al. (2017) for their computation. As shown in Nguyen et al. (2013), anyx(k)∈PNcan be decomposed as a convex combination of xv∈PNand xo∈Ω: x(k) = c(k)xv(k) + (1−c(k)) xo(k),(6) with 0≤c≤1; while considering the following control law: u(k)=c(k)uv(k) + (1−c(k)) uo(k),(7) where uv(k) is the vertex control law (Gutman and Cwikel, 1986) at xv(k) and uo(k)=Kxo(k) is the control (3) in Ω. Since the controller (3) is designed to give specified unconstrained performance in Ω, it may be desirable to have u(k) in (7) as close as possible to it also outside Ω, which can be achieved by solving the linear programming (LP) problem c⋆(x) = min c,rv cs.t.   FNrv≤cgN, Fo(x−rv)≤(1 −c)go, 0≤c≤1, (8) where rv=cxv∈Rnxand ro=(1−c)xo∈Rnx. The implicit interpolating control then consists in implementing the control input per (7) with c⋆(k) from (8) at each sample k. Now, as proven in Nguyen et al. (2016), for all x∈ PN\Ω, the controller (6), (7), (8) is a piecewise affine (PWA) state feedback law defined over a partition of PN\Ω into simplices, and the controller gains are obtained by linear interpolation of the control values at the vertices of simplices. The procedure of obtaining an explicit solution of interpolating control is summarized in Alg. 1 (Nguyen et al., 2016). Algorithm 1 Interpolating control – Explicit solution Input: The sets PN, Ω, the local controller u=Kx in Ω, and the control values at the vertices of PN. Output: PWA control law over the partition of PN. 1: Solve the LP (8) by parametric programming to obtain the state-space partition of PN,c⋆(x) and r⋆ v(x). 2: Decompose each partition of PN\Ω in a sequence of simplices, each formed by rvertices of PNand n−r+1 vertices of Ω, where 1 ≤r≤nx, resulting in the statespace partition over PN\Ω in the form of simplices Ri. 3: In each simplex Ri⊂PN\Ω the control law is given as: u(x)=Lix+vi,(9) where Li∈Rnu×nxand vi∈Rnuare defined as [Livi] = hu(i) 1u(i) 2. . . u(i) n+1iv(i) 1v(i) 2. . . v(i) n+1 1 1 ... 1−1 , with {v(i) 1,v(i) 2,...,v(i) n+1}being vertices of Ri, which is a full-dimensional simplex, and {u(i) 1,u(i) 2,...,u(i) n+1} are the corresponding control values at the vertices. Note that the PWA control law (9) not only guarantees recursive feasibility and asymptotic stability for all x(0) ∈ PN, but is also optimal for all x∈Ω. Assuming a sample system (1) with constraints (2), Fig. 1 illustrates the computed sets Ω and PNwhich are used to design an implicit interpolating controller per (6)–(8). The state-space partition resulting from its explicit solution per Alg. 1 is depicted in (b), with distinguished un/saturated regions (see Sec. 2.2). One may inspect the low-complexity structure of the simplex-based partitioning of PN\Ω, compared to the structure of an EMPC controller in (c) with terminal set and feasible set designed equivalent to Ω and PN, respectively. The simulated state trajectories also hint that EIC is likely to perform nearly optimal w.r.t. EMPC. -5 -4 -3 -2 -1 0 1 2 3 4 5 x2 -10 -8 -6 -4 -2 0 2 4 6 8 10 x1 (a) -10 -8 -6 -4 -2 0 2 4 6 8 10 closed-loop state trajectory x1 (b) -10 -8 -6 -4 -2 0 2 4 6 8 10 x1 (c) Fig. 1. Illustration of (a) construction of Ω and PNof an interpolating controller, (b) state-space partition of the resulting EIC controller, and (c) of an equivalent EMPC controller, for a double integrator system assuming N= 20 steps. 2.2 Lifted implementation of explicit interpolating control Before introducing the convex lifting based (lifted) implementation of explicit interpolating control (LEIC), let us for ease of presentation assume nu=1 and denote the piecewise affine control law resulting from Alg. 1 as: u(x) =      l1x+v1if x∈ R1, . . . lRx+vRif x∈ RR, (10) defined over the Rpolyhedral regions Riin the state space, given as convex intersections of finitely many closed halfspaces, i.e. Ri={x|Hix≤hi},i∈ IR,IR= 1, . . . , R. Let us now recall the definition of a convex lifting (Nguyen et al., 2018): Definition 2.1. Given a polyhedral (polytopic) state-space partition {R}i∈IRof a polyhedron (polytope) R⊆Rnx, ℓ(x)=aT ix+bifor x∈ Ri,(11) is called convex piecewise affine lifting (for brevity henceforth referred to as convex lifting) if the following holds: •ℓ(x) is continuous over R, in the case of EIC over PN, •for each i∈ IR,ℓ(x)>aT jx+bjfor all x∈ Ri\Rj and all j=i, j ∈ IR. The algorithm for construction of convex lifting for a given state-space partition can be found in Nguyen et al. (2018), and consists in registering all pairs of neighboring regions in {Ri}i∈IR , imposing continuity and convexity conditions on their relevant vertices, and solving a simple constrained minimization problem, to obtain the gains (ai, bi),∀i∈ IR of a convex lifting ℓ(x) defined over {Ri}i∈IR. Now, as shown in Nguyen et al. (2018), a convex lifting by definition implies the following property: x∈ Rj⇔j= arg max i∈IR (aT ix+bi),(12) indicating that the polyhedral region Rjcontaining state xcan simply be identified by searching for the maximum among the list {aT ix+bi}, i ∈ IR. This enables to efficiently identify the j-th affine control law ljx+vjto be evaluated at given x∈ PN, without the need for traversing and even storing {R}i∈IRas in the traditional—region-based implementation of explicit control, such as EMPC or EIC. Here, one may also efficiently exploit the fact that in most practical constrained control setups the state-space partition contains many saturated regions {R}i∈Imax ∪Imin , i.e. regions over which the PWA function u(x)=lix+viattains the maximum and the minimum values, uand u, respectively; see Gulan et al. (2017) for a formal definition. In particular, we can construct a convex lifting of only the unsaturated regions to obtain the gains (ai, bi),∀i∈ Iuns of a convex lifting ℓuns(x), defined over {Ri}i∈Iuns , while commonly |Iuns|≪R(cf. Fig. 2). As shown in Gulan et al. (2017), if we extend ℓuns(x) as ˜ ℓ(x) = max i∈Iuns (aT ix+bi) for x∈ R, equivalence of the associated PWA function ˜u(x) and u(x)(10) over the entire feasible domain Rcan be established by employing a suitable clipping filter ϕ(·): u(x) = ϕ(˜u(x)) =    uif ˜u(x)≥u, uif ˜u(x)≤u, ˜u(x) otherwise. (13) The efficient LEIC implementation then, at each sampling instant, amounts to obtaining the current state x(k), finding the index j= arg max i∈Iuns (aT ix+bi), and evaluating the control input per (13), encoded as u0= max{u,min{˜ ljx0 +˜vj, u}}, which is applied to the controlled system. Note that the procedure is identical if |Iuns|=Rwas the case. It also may be easily extended to multiple-input systems. The regionless, convex lifting based implementation inherently comes with a significantly reduced memory footprint and online evaluation effort. We refer an interested reader to Gulan et al. (2017) for a detailed complexity analysis. To illustrate the benefits of the LEIC implementation over the standard EMPC or EIC implementation, Fig. 2 shows the state-space partition of a sample EMPC controller and of an EIC controller with equivalently designed Ω and PN. It also shows partitions corresponding to LEIC and LEIC with clipping (LEIC-c), and closed-loop state trajectories simulated from the same initial condition, that are nearly identical for the optimal EMPC and suboptimal (L)EIC. We also remark that the simplex-based partitioning of the EIC controllers, induced in Step 2of Alg. 1, indeed renders them perfect candidate for a simple construction of a convex lifting; cf. the structure of {Ri}in (b) and (a) in Fig. 2. -10 -8 -6 -4 -2 0 2 4 6 8 10 x1 -500 -400 -300 -200 -100 0 100 200 300 400 500 x2 closed-loop state trajectory (a) 5207 regions, used in the region-based EMPC implementation. -10 -8 -6 -4 -2 0 2 4 6 8 10 x1 (b) 113 regions, used/avoided in the regionbased/-less EIC/LEIC implementation. -10 -8 -6 -4 -2 0 2 4 6 8 10 x1 (c) 39 regions, avoided in the regionless LEIC-c implementation. Fig. 2. Illustration of the state-space partition of (a) an EMPC controller, (b) an equivalent EIC / LEIC controller, and (c) one corresponding to a LEIC controller with clipping, for the AVC system in Sec. 3 assuming N= 50 steps. 3. ACTIVE VIBRATION CONTROL CASE STUDY The following practical case study is considered to demonstrate the performance and the real-time feasibility of the LEIC controllers when implemented on low-cost resourceconstrained embedded computing hardware. Furthermore, these tests shall illustrate the practical memory and computational effort required, thereby indicating the real-life application potential of the proposed approach. We have chosen the Microchip Technology Inc. ATtiny85 microcontroller unit (Fig. 3a) to implement the proposed control algorithms. This device is an 8-bit reduced instruction set computer (RISC) using the popular AVR architecture. The chip contains a mere 8 kB of program memory and 512 bytes of random-access memory (RAM). There are 8 physical pins on the component serving power, reset circuitry and external clock; leaving only a few for actual peripheral use. The CPU can be clocked externally at 20 MHz, effectively achieving 20 million instructions per second (MIPS). The component costs well below 1 USD for large quantity purchases and this, along with its miniature size and low power consumption, makes it an ideal choice for mass-produced, low-cost consumer devices. (a) ATtiny85 microcontrollers. (b) Purpose-made MCU prototyping board. Fig. 3. The Atmel ATtiny85 MCU chips in a through-hole (back) and surface mount (front) package in true size compared to a 2 ecoin in (a) and the custom-made prototyping board used in experiments in (b). The algorithms were deployed and run on the MCU that was embedded into the simple purpose-made prototyping tool shown in Fig. 3b. This provided power, programming and signal interfacing to the experiments. The control output can be passed to the actuator via a pulsewidth modulated (PWM) signal or via a PWM-to-analog converter chip. The prototyping board also contains a single analog input for connecting the sensor, and a pulse-width encoded digital timing output to gauge algorithm execution timing. Note that the control framework was kept to its absolute possible minimum, consisting only of interrupt-based timPC DAQ MCU (d) A (g) (h) (i) (a) (b) (c) (f) DSP (e) u(k)y(k) Fig. 4. A simplified schematic representation of the active vibration control experiment. ing, analog-to-digital conversion and PWM signal generation. The controller code itself was developed and compiled using Microchip Studio in both studies, and the obtained machine code was deployed to the MCU via the Atmel-ICE in-circuit system programmer (ICSP) and debugger. Our case study for the embedded implementation of LEIC involves an active vibration control (AVC) system. This choice was motivated by its strongly second-order behavior and relatively fast sampling time. In the experimental setup that is illustrated in Fig. 4, a cantilever beam (a) fixed to a sturdy base (b) emulates the dynamic behavior of a class of highly flexible mechanical structures. A pair of piezoceramic transducers (c) are fastened at the fixed end of the cantilever; these are supplied by a high-voltage input through an amplifier (d). The displacement of the free end of the beam is measured by a laser triangulation sensor (e) connected to a configurable signal processing unit (f). The linearly scaled analog output signal y(k) from the sensor toolchain and the input u(k) from the actuator toolchain are connected to the ATtiny85 MCU embedded into the custom prototyping board (g) described previously. An external data acquisition device (h) gathers the input, output and timing signals, which are saved on a computer (h) that is also used to deploy the compiled code onto the MCU. The dynamic behavior of this system is dominated by the first resonant frequency of the beam, therefore it is possible to approximate it by a single-degree-of-freedom externally driven harmonic oscillator given by ¨q(t) + 2ζω ˙q(t)+ω2q(t) = cu(t),(14) where q(t) denotes the position measured at the end, u(t) is the driving voltage supplied to the piezo transducers, ωis the undamped natural angular frequency (first resonance) of the beam, ζis its damping ratio and cdenotes a constant relating the mass-specific force induced by the driving signal. The parameters of the model were identified using a grey-box technique from measurement data as ω= 50.89 (-) or f= 8.10 Hz, ζ= 0.005 (-) and c= 5.91 N V−1kg−1. The dynamical system (14) was transformed into the statespace representation, then discretized at Ts= 10 ms. The resulting second-order discrete-time state-space model was then used to design the controllers and the state observer. The goal of control applied to this AVC system is to drive the end of the beam to the equilibrium after an initial deflection that is followed by no other external disturbance. No constraints on the states were assumed, but the inputs were bounded by the depolarization limit of the piezoceramic transducers to −100 ≤uk≤100 V for k=1, . . . , N. y(k) (mm) u(k) (V) Time (s) c TET (ms) Fig. 5. Output (top), input (middle) and execution timing (bottom) of the closed-loop AVC system with the lifted EIC algorithm running on the ATtiny85 MCU. The reader shall also note, that in order to cover an initial deflection range of q0≈ ±5 mm, we must assume a horizon of N= 50 steps. All controllers investigated here assume an input penalty of r=1 and state penalty Q=diag(1,1), while the terminal penalty was again chosen LQ-optimal. The EIC problem was constructed and solved according to Alg. 1 with the help of Multi-Parametric Toolbox (Herceg et al., 2013). The obtained explicit solution was then used to construct the LEIC controller as per Sec. 2.2, which took approx. 5 s. This was then passed through a custom code generation routine so as to yield a C-code tailored for the MCU. Note that the computed EIC controller consisted of 113 regions, which are in turn not needed in the regionless LEIC implementation. Interestingly, an equivalent yet not implementable EMPC controller consists of 5207 regions. Some light on the structure of controllers is shed in Fig. 2 which well illustrates the low-complexity nature of LEIC. The experimental results featured in Fig. 5 demonstrate the output and input of the AVC system under the lifted version of the EIC algorithm (blue). Even though we chose to show the closed-loop input-output response of the beam under LEIC, the responses would be identical for EIC and LEIC-c (LEIC with clipping) as well. Although the performance of the interpolating control is by design suboptimal to that of MPC, the settling time of the beam to equilibrium is still reduced to well under 2 s from the open-loop response (grey) that takes nearly 30 s to settle. The input constraints are met shortly after the beam is released from its initial position resulting in an aggressive control at the beginning that is more tamed as the state enters the maximum admissible set Ω. On one side, this control strategy ensures a fast settling time, but it also implies a low-complexity explicit solution, the memory footprint and evaluation time of which is further reduced via the convex lifting based implementation, with possible clipping as well. Note also that this implementation can be further accelerated by first checking if x(k)∈Ω and, if so, applying (3) directly. The bottom graph of in Fig. 5 features the execution timing for the LEIC algorithm and its clipped variant along with the computational overhead. This overhead includes a conventional implementation of digital feedback control including sampling, input-output peripheral control; along with a Kalman filter and a 8-th order cyclic finite impulse response moving average filter to remove the static component of the position measurement. This overhead was evaluated in less than 1.5 ms and required 3.5 kB of storage memory and 139 bytes of ROM. This is caused by the need for Kalman filter and in-processor digital signal processing. All the memory and timing data listed hereinafter includes this overhead unavoidable for a practical implementation. Due to the inherent structure of the the lifted controllers, their evaluation time is consistent throughout the experiments and not dependent on the given state. In this case study, LEIC implementation required a maximum execution time of 9.3 ms averaging at 9.0 ms. The clipped variant further reduced these to 6.6 ms and 6.4 ms, respectively. Let us remark that the experiments were not designed to demonstrate the performance of the proposed controllers, instead, to emphasize the fact that it is possible to implement this near-optimal constrained control strategy onto such extremely limited hardware. The reader may wonder how the non-lifted EIC or even the optimal EMPC fares in experiments, however, it was not possible to deploy these on the microcontroller for this case study. Conventional EMPC could not be realized, for it resulted in a 11.3 kB machine code for a mere 5-step horizon. Similarly, the EIC algorithm exceeded the available flash storage for a dynamic closed-loop test given the same parameters by 2.4 kB. Because of these limitations, we have decided to illustrate the practical properties of various controllers using a static timing and memory footprint test. A static test evaluates memory precisely, while the stable timing profile in Fig. 5 suggests that timing data related to any state is representative of the the overall real-time execution requirements. Each controller variant was deployed to the MCU with an increasing prediction horizon and a full feedback control overhead. The state to be evaluated by the controllers was chosen as x(k) = [2 200]T(mm, mm−1) as this is feasible even for a horizon of N=5 steps. The RAM space required was 149 bytes in each case, and as it is noted above, all results include overhead. Execution time (ms) ROM (kB) 5 10 15 20 25 5 10 15 20 25 30 35 40 45 50 55 60 5 10 15 20 25 30 3540 45 50 55 60 65 70 75 80 85 90 95 100 c Fig. 6. Static timing and memory footprint test evaluated on the ATtiny85 MCU. The data point labels denote horizon lengths. The horizon dependent scaling of controller complexity is shown in Fig. 6 for all deployable controller variants. The most demanding on deployment is EIC (grey line), which reaches the maximum available flash memory with a small reserve in execution time. The convex lifting reduces the implementation burden greatly, as LEIC (blue) is deployable to hardware with a horizon up to N= 60 steps, after which the execution time overflows the allotted sampling period. The clipping applied to LEIC (red) curtails deployment cost even further, allowing for horizons up to N= 100 steps, which, in a manner similar to LEIC, is halted by the 10 ms sampling limit. Note that the on-board flash memory of microcontrollers is an important factor in component price and the memory categories are usually differentiated by powers of two. Although our self-imposed storage limit of 8 kB is extremely small, the EIC alone may still present a feasible choice for control implementation on devices in the typical range of 16-32 kB. Also, notice that the dynamics of the cantilever beam yielded no LEIC controller under 4 kB. The manufacturers tend to divide microcontroller families along the amount of on-board flash memory available, and 4 kB is a typical division line for even lower-end products, suggesting that for systems with a less complex dynamics the LEIC controllers can be deployed to a class of MCUs even simpler than the one considered here. 4. CONCLUSION In this paper we presented a constrained control alternative to linear model predictive control, based on the concept of convex lifting, deployable on severely limited hardware. In particular, convex lifting was applied on the interpolation-based control framework—an improved extension of the vertex control—where it was shown to efficiently exploit the properties of its explicit solution. The proposed lifted EIC implementation is by the design of interpolating control suboptimal with respect to MPC, albeit highly efficient, both in terms of memory footprint and online evaluation effort. It was successfully deployed and run on a minimalist 8-bit ATtiny85 MCU and experimentally tested in a practical AVC case study. The possibility to implement constrained near-optimal control on low-end embedded microcontrollers—even at faster sampling speeds—may bring the benefits of advanced model-based control to mass-produced devices at a reasonable price. The featured study may then serve as a simple guide for implementation in a wide class of real-world embedded control applications. A motivation for future work may be a comparison of LEIC with state-of-the-art MPC solvers tailored for MCUs (see e.g. Nguyen et al. (2024)) in practical applications, as well as an extension of the framework for nonlinear systems. REFERENCES Borrelli, F., Bemporad, A., and Morari, M. (2017). Predictive Control for Linear and Hybrid Systems. Cambridge University Press. Ferreau, H., Alm´er, S., Verschueren, R., Diehl, M., Frick, D., Domahidi, A., Jerez, J., Stathopoulos, G., and Jones, C. (2017). Embedded optimization methods for industrial automatic control. IFAC-PapersOnLine, 50(1), 13194–13209. 20th IFAC World Congress. Gulan, M., Nguyen, N.A., and Tak´acs, G. (2020). Convex lifting based inverse parametric optimization for implicit model predictive control: A case study. In Proc. 59th Conf. Decis. Control, 2501–2508. Gulan, M., Tak´acs, G., Nguyen, N.A., Olaru, S., Rodriguez-Ayerbe, P., and Rohaˇ l-Ilkiv, B. (2017). Embedded linear model predictive control for 8-bit microcontrollers via convex lifting. IFAC-PapersOnLine, 50(1), 10697–10704. 20th IFAC World Congress. Gulan, M., Tak´acs, G., Nguyen, N.A., Olaru, S., Rodriguez-Ayerbe, and Rohal’-Ilkiv, B. (2019). Efficient embedded model predictive vibration control via convex lifting. IEEE Trans. Control Syst.Technol., 27(1),48–62. Gutman, P.O. and Cwikel, M. (1986). Admissible sets and feedback control for discrete-time linear dynamical systems with bounded controls and states. IEEE Trans. Autom. Control, 31(4), 373–376. Herceg, M., Kvasnica, M., Jones, C., and Morari, M. (2013). Multi-Parametric Toolbox 3.0. In Proc. 12th Eur. Control Conf., 502–510. Ioan, D., Olaru, S., Prodan, I., Stoican, F., and Niculescu, S.I. (2020). From obstacle-based space partitioning to corridors and path planning. a convex lifting approach. IEEE Control Syst. Letters, 4(1), 79–84. Karg, B. and Lucia, S. (2021). Model Predictive Control for the Internet of Things, 165–189. Springer Int. Publish. Nguyen, H.N., Gutman, P.O., Olaru, S., and Hovd, M. (2013). Implicit improved vertex control for uncertain, time-varying linear discrete-time systems with state and control constraints. Automatica, 49(9), 2754–2759. Nguyen, H.N., Gutman, P.O., Olaru, S., and Hovd, M. (2016). Explicit improved vertex control for uncertain, time-varying linear discrete-time systems with state and control constraints. Int. J. Robust. Nonlinear Control, 26(12), 2652–2667. Nguyen, K., Schoedel, S., Alavilli, A., Plancher, B., and Manchester, Z. (2024). TinyMPC: Model-predictive control on resource-constrained microcontrollers. In Proc. 2024 Int. Conf. Robot. Automation. In print. Nguyen, N.A., Gulan, M., Olaru, S., and RodriguezAyerbe, P. (2018). Convex lifting: Theory and control applications. IEEE Trans. Autom. Control, 63(5), 1243– 1258.