🔬 applied physics

FPGA-based LQG controller and hardware-in-the-loop simulator implementation for nanomechanical systems

This paper presents an open-source, MATLAB-automated framework for deploying real-time Linear Quadratic Gaussian (LQG) control and hardware-in-the-loop simulation on the affordable Red Pitaya FPGA platform, demonstrated through the successful stabilization of a levitated nanoparticle in a double-well potential.

Original authors: Vojtěch Mlynář (Automation and Control Institute, TU Wien, Vienna, Austria), Johannes Berndorfer (Automation and Control Institute, TU Wien, Vienna, Austria), Andreas Kugi (Automation and Control Inst

Published 2026-07-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vojtěch Mlynář (Automation and Control Institute, TU Wien, Vienna, Austria), Johannes Berndorfer (Automation and Control Institute, TU Wien, Vienna, Austria), Andreas Kugi (Automation and Control Institute, TU Wien, Vienna, Austria, AIT Austrian Institute of Technology, Vienna, Austria), Andreas Deutschmann-Olek (Automation and Control Institute, TU Wien, Vienna, Austria)

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: A "Flight Simulator" for Tiny Machines

Imagine you are trying to teach a tiny, invisible marble (a nanoparticle) to hover perfectly still in mid-air using a laser beam. This is the world of nanomechanics. The problem is that the air is full of invisible bumps (thermal noise) that knock the marble around, and the laser has to push back incredibly fast to keep it steady.

Doing this in real life is dangerous and expensive. If your control system is too slow or makes a mistake, the marble flies away, or the laser burns out.

The authors of this paper have built a digital playground (a framework) that lets scientists design, test, and perfect their control systems on a cheap computer chip before they ever touch the real, expensive equipment. They call this a "Hardware-in-the-Loop" (HIL) system.

Think of it like a flight simulator for pilots. Before a pilot flies a real plane, they practice in a simulator that mimics wind, turbulence, and engine failure. This paper provides the software and the "simulator plane" so scientists can practice controlling their tiny marbles without crashing the real thing.

The Two Main Tools

The paper presents two complementary tools that work together on a device called a Red Pitaya (which is like a very fast, affordable, programmable computer chip).

1. The "Smart Pilot" (The LQG Controller)

This is the brain that tells the system how to push the marble to keep it steady.

How it works: It uses a mathematical method called LQG (Linear Quadratic Gaussian).
- The Detective (Kalman Filter): The sensors can't see the marble's speed perfectly, only its position. The "Detective" part guesses the speed and other hidden details based on the noisy data.
- The Driver (LQR): Once the Detective knows where the marble is and how fast it's going, the "Driver" calculates the exact push needed to stop it from wobbling.
The Challenge: Real nanoparticles move so fast (thousands of times a second) that a normal laptop is too slow to react. This tool runs on a specialized chip (FPGA) that reacts in nanoseconds (billionths of a second).
The Magic Trick: The authors figured out how to make this complex math run on a chip that only does simple math (fixed-point arithmetic). They used a technique like scaling a map: if the numbers are too big or too small for the chip, they shrink or stretch them temporarily so the chip can handle them, then stretch them back to real size for the user.

2. The "Virtual Marble" (The HIL Simulator)

This is the fake world that tricks the "Smart Pilot" into thinking it's controlling a real marble.

How it works: It creates a virtual environment where a particle bounces around. It can simulate:
- Wind: Random bumps (noise) hitting the particle.
- Gravity: Forces pulling the particle down.
- Tricky Traps: The paper demonstrates a "double-well" potential. Imagine a marble sitting in a valley between two hills. It's stable there. But the simulator can also create a "saddle" shape (like a Pringles chip), where the marble is balanced on a ridge. If it moves slightly to the left, it rolls down; if it moves right, it rolls down the other way. This is an unstable situation that is very hard to control.
The Benefit: Scientists can test their "Smart Pilot" against this tricky, unstable virtual marble. If the pilot fails in the simulator, they just tweak the code. If they fail in the real lab, they might lose their equipment.

The "Easy Button" Workflow

One of the biggest hurdles in this field is that programming these chips usually requires being a computer engineering expert. The authors created a MATLAB-based workflow (a user-friendly interface) that acts like a "wizard."

No Coding Required: You don't need to write the complex math code yourself. You just tell the software: "My particle weighs this much," "The wind blows this hard," and "I want to stabilize it."
Automatic Translation: The software automatically does the hard math:
1. It turns the continuous physics into digital steps.
2. It figures out the perfect "push" settings.
3. It converts the numbers into the specific format the chip understands.
4. It uploads the program to the chip.

The "Grand Finale" Demonstration

To prove it works, the authors ran a full test:

They set up the Virtual Marble in a tricky, unstable "saddle" shape (the Pringles chip shape).
They turned on the Smart Pilot.
They watched the pilot stabilize the virtual marble.
The Switch: They then switched the virtual world from a stable valley to the unstable saddle while the pilot was still flying.
The Result: The pilot successfully caught the marble before it fell off the edge. They even showed that if you switch the world before the pilot is ready, the marble crashes.

Why This Matters (According to the Paper)

The paper claims this is a complete, open-source toolkit.

It's Affordable: It runs on cheap, off-the-shelf hardware (Red Pitaya) instead of million-dollar custom machines.
It's Safe: You can break your virtual marble as many times as you want without cost.
It's Accessible: It removes the need for deep computer engineering skills, allowing physicists to focus on the physics rather than the code.

In short, they built a training ground and a control brain that makes it much easier for scientists to master the art of holding tiny particles steady in mid-air.

Technical Summary: FPGA-based LQG Controller and HIL Simulator for Nanomechanical Systems

Problem Statement

Active feedback control and state estimation are critical for stabilizing high-Q nanomechanical systems, such as levitated optomechanics and MEMS/NEMS, which are subject to external stochastic disturbances. While the Linear Quadratic Gaussian (LQG) regulator offers a theoretically optimal solution combining Kalman filtering (KF) for state estimation and Linear Quadratic Regulator (LQR) for control, its practical deployment in laboratory settings faces significant hurdles. Natural frequencies in the tens to hundreds of kilohertz necessitate sampling rates exceeding the capabilities of general-purpose computers and microcontrollers, requiring Field-Programmable Gate Arrays (FPGAs). Furthermore, reliable implementation on FPGAs introduces complexity regarding fixed-point arithmetic, numerical scaling, and hardware deployment. Existing FPGA solutions for Kalman filters and LQR controllers are often tailored to specific experiments, require substantial FPGA expertise, or lack open-source availability, leaving a gap for an integrated, accessible workflow that automates controller synthesis and hardware deployment on low-cost platforms.

Methodology

The authors present an open-source framework comprising two complementary modules implemented on the Red Pitaya STEMlab 125-14 Z7020 (a Xilinx Zynq Z7020 system-on-chip): an FPGA-based LQG controller and a Hardware-in-the-Loop (HIL) simulator.

1. LQG Controller Architecture

The controller targets systems with up to three coupled oscillatory degrees of freedom plus a drift term, modeled as a linear continuous-time system with additive process and measurement noise.

Mathematical Formulation: The system is discretized using the Van Loan method at a sampling period of $T_s = 64$ ns. The controller employs a discrete-time Kalman filter for state estimation and an LQR for optimal control. The LQR cost function is weighted by mechanical energy, derived directly from physical noise covariances and cost weights to minimize manual tuning.
Fixed-Point Implementation: To balance precision and resource consumption on the FPGA's DSP48E1 slices, the implementation utilizes fixed-point arithmetic with a unique "shift-float" encoding. Matrix coefficients are decomposed into a fixed-point residue and a per-element unsigned integer exponent (bit shift), allowing for a wide dynamic range without floating-point hardware overhead.
State-Space Transformation: To ensure numerical stability, the controller applies state-space transformations. These include physical state normalization (equalizing displacement and velocity scales) and numerical balancing derived from the predicted closed-loop covariance, ensuring internal states utilize the full dynamic range of the fixed-point representation without overflow.
Configuration and Deployment: A MATLAB-based workflow automates model configuration, gain computation, and FPGA deployment. A Python REST API server running on the Red Pitaya's processor handles live parameter updates, data acquisition, and calibration (ADC/DAC offsets and gains) without requiring FPGA recompilation. The system supports two independently switchable parameter sets for real-time model switching.

2. HIL Simulator Architecture

The HIL simulator provides a configurable, second-order stochastic plant for realistic closed-loop testing.

Model: It solves stochastic differential equations for three degrees of freedom with configurable nonlinearities in damping, restoring forces, and input/output mappings. The model is driven by pseudorandom Gaussian white noise generated via Linear Feedback Shift Registers (LFSR) and Box-Muller transforms.
Implementation: The architecture uses three independent state-processing slices to enable parallel execution. It employs a semi-implicit Adams-Bashforth/Adams-Moulton integrator for numerical stability. Nonlinear functions are implemented using Look-Up Tables (LUTs) with linear interpolation to ensure deterministic latency.
Latency and Precision: The system operates at a 6.944 MS/s sampling rate with a total worst-case input-output delay of approximately 788 ns (including ADC/DAC conversion). The simulator uses a lightweight C-based configuration server on the processor to receive model parameters from MATLAB and transfer them to the FPGA via memory-mapped I/O.

Key Contributions

Integrated Open-Source Workflow: The paper provides a complete, open-source pipeline that bridges the gap between theoretical control design and FPGA deployment. It automates discretization, gain computation, fixed-point scaling, and hardware configuration via a MATLAB GUI, removing the need for specialized embedded software or FPGA development knowledge.
Affordable Hardware Platform: The solution is demonstrated on the low-cost Red Pitaya STEMlab platform, making high-speed LQG control accessible to a broader research community.
Advanced Fixed-Point Strategies: The implementation introduces specific techniques for fixed-point arithmetic, including per-element scaling exponents and automated state-space balancing, to maintain numerical stability in resource-constrained environments.
Real-Time Model Switching: The system supports the simultaneous storage of two parameter sets, allowing for instantaneous switching between different controller configurations (e.g., stabilizing different potential landscapes) without halting the control loop.
Comprehensive Validation: The framework includes a HIL simulator capable of emulating nonlinear and stochastic dynamics, enabling safe validation of controllers before physical deployment.

Results

The authors demonstrate the framework through an end-to-end example involving the stabilization of a levitated nanoparticle in a two-dimensional double-well potential.

Scenario: The system simulates a particle exploring both a fully confining quadratic potential and an unstable saddle potential.
Performance: The LQG controller successfully stabilizes the particle in both potential configurations. The experiment demonstrates live switching between the confining and saddle potentials. Crucially, the controller is switched to the appropriate parameter set (Set 2 for the saddle potential) before the simulator potential is switched, ensuring the particle remains confined during the transition to the unstable regime.
Verification: The system successfully records internal states and signals at full sampling resolution, verifying the reduction of mechanical energy (variance) in the feedback loop. The HIL simulator accurately emulates the plant dynamics, including the effects of thermal noise and nonlinear potential switching.

Significance and Claims

The paper claims to address a practical gap between established control theory and routine laboratory deployment. By lowering the technical barrier to high-speed state estimation and optimal control on low-cost hardware, the authors aim to support reproducible research and accelerate the adoption of advanced feedback techniques in levitated optomechanics, MEMS/NEMS, and precision sensing. The framework is presented not as a final, universal solution for all model structures, but as a robust foundation for the specific class of coupled harmonic oscillators with drift, with the potential for users to extend the configuration tooling for different model structures. The work serves as a high-level overview and a "first-steps guide," directing users to detailed documentation for in-depth technical references.