A grid-following inverter treats voltage and frequency as given. It locks onto them with a phase-locked loop and injects the current it was asked to inject. It is a current source that happens to be polite about phase. Remove the grid and it has nothing to lock onto — the PLL has no reference, and the inverter shuts down.
A grid-forming inverter treats voltage and frequency as things it produces. It behaves like a voltage source behind an impedance, and it decides its own angle. That’s the whole shift: from “what does the grid want from me” to “what should the grid look like.”
Once an inverter forms its own voltage, two of them on the same bus have a problem. Nothing keeps their angles aligned, and even a small angle difference between two stiff voltage sources pushes enormous circulating current between them.
Droop control solves this by making each unit’s frequency depend on the real power it’s delivering, and its voltage on the reactive power. Take on more load, run slightly slower. Because every unit on the microgrid ultimately settles at one common frequency, this quietly forces them to share load in proportion to their droop coefficients — with no communication link at all.
It’s a beautiful mechanism, and it costs you something: the settled frequency is not the nominal frequency. Droop is a proportional controller, so it leaves steady-state error by construction.
Something has to push frequency back to nominal after droop has done the sharing. In a conventional system that’s a slow integral controller sitting above the droop loop.
That layer is where my thesis lives. The plant it acts on is nonlinear — power flow involves sines of angle differences, and the LCL filter and dynamic loads add their own dynamics — so the conventional answer is a PI controller tuned around one operating point and hoped to be adequate at the others.
The alternative I’m testing is to learn a linear predictor for the lifted dynamics and put constrained MPC on top of it. Same job, better excursions, and honest constraint handling instead of anti-windup patches.
More on how that turns out as the results come in.
]]>The fix was one observable: a constant. Setting the first entry of the lifted state to 1 for every sample.
EDMDc fits a linear map from lifted state and input to next lifted state. Every term in that map is proportional to something in the data. If the true dynamics have any offset that doesn’t scale with the state — an equilibrium that isn’t at the origin, a bias in the measurement, a load contribution the input doesn’t see — a purely linear map has no way to express it. It can only approximate the offset by bending the state-dependent terms, and those bends compound every time you roll the prediction forward.
Including a constant observable gives the regression an affine term. The identified model becomes
z(k+1) = A z(k) + B u(k) + c
with c absorbed into A through the constant entry. Now the offset is represented
once, explicitly, instead of being smeared across the state matrix.
Multi-step NRMSE dropped to 2.25%.
Rescaling the inputs and outputs to comparable magnitudes mattered almost as much. Real power setpoints live in the hundreds of watts; frequency deviations live in hundredths of a hertz. Handed to a least-squares solve unscaled, the DC gain of the identified model is conditioned badly enough that the controller’s steady-state behaviour is essentially arbitrary — not unstable, just quietly wrong.
Neither of these is a contribution. Both are the difference between a pipeline that produces a result and one that produces a plot you have to apologise for.
The third one is the trap. One-step error flatters every model ever fitted.
]]>