Controller Blend 2D — Control Systems/Gain Scheduling

2D Controller Blend

Control Systems / Gain Scheduling

The Aerospace Blockset's 2D Controller Blend: the 1D Controller Blend nested. Three controllers are blended along v1, and each of those three is itself a 1D Blend along v2 – nine self-conditioned state-space controllers, each sitting at one (v1, v2) breakpoint pair and carrying its own state. As a variable crosses a breakpoint the controllers change ROLES rather than breakpoints, so no controller's state jumps.

A controller at breakpoint pair (i, j): dx/dt = H·u + (B − H·D)·y + (A − H·C)·x,   its output C·x + D·y (every matrix that pair's), where u is the blended output fed back to all nine and H places the poles of A − H·C at Poles.

Each variable has its own copy of the 1D Blend's role machine. With a variable in [bp_k, bp_k+1) and fraction f, its three roles are: the breakpoint above with weight f; the one below with weight 1 − f; and a standby, weight 0, at bp_k+2 when f ≥ 0.5 or bp_k−1 when f < 0.5 (clamped to the table). The inner blend along v2 is formed for each of the three outer controllers, and the v1 weights blend those three. Each variable is clamped to its breakpoints at both ends.

When a variable's interval index goes up by one, its controllers move one role on (above becomes below, below becomes standby, standby becomes above); down by one, one role back. The roles start as above, below, standby. The rotation fires on a rising edge of the index change: an index that changes on two consecutive samples rotates once, and the first sample never rotates – exactly as the Simulink block's triggered subsystems behave.

Ports

• y – the controller input, an [m,1] column, m being the column count of the B and D matrices.
• v1 – the first scheduling variable, a scalar.
• v2 – the second scheduling variable, a scalar.
• u – the blended controller output, a scalar.

Parameters

• A Matrices – the n×n A matrix for every breakpoint pair, stacked vertically with the first variable varying fastest: [P₁·P₂·n, n]. From a MATLAB array A(:,:,i,j) the config is reshape(permute(A,[1 3 4 2]),[],size(A,2)).
• B Matrices – the n×m B matrices, stacked the same way.
• C Matrices – the 1×n C rows, stacked the same way. One output only.
• D Matrices – the 1×m D rows, stacked the same way.
• Breakpoints v1 – the P₁ values of v1, strictly increasing, at least two.
• Breakpoints v2 – the P₂ values of v2, strictly increasing, at least two.
• Initial State – every controller's x at the start: a scalar or an [n,1] column. Default 0.
• Poles – the n poles of A − H·C, real and distinct. Default [−5 −2], Simulink's.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

H_j is computed at the start of a run by Ackermann's formula on the observer dual. With one output that is the only gain placing the poles, so it is the one Simulink's place returns; the configuration is refused if a C row and its A leave the state unobservable, if two poles coincide, or if C has more than one row.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. The schedule, the gains H and the matrices A − HC and B − HD are baked in; the two role machines and the nine states integrate with forward Euler at the block's period. The emitted core grows with the nine controllers times the P₁·P₂ arms that address them. All ten are rendered from the one description of the arithmetic the block's own simulation runs.

The three HDL targets are simulation-only: the fraction divides by a signal difference, so they compute in real arithmetic and quantize only at the ports.

Simulink bridge

None (Support::None), for the 1D Controller's reason: the four matrix parameters of aerolibschedule/2D Controller Blend are four-dimensional arrays, and neither MATLAB's matrix literal syntax nor an ICore matrix config has that form. The block is reported rather than exported without its matrices; it has no parity testbench, and code export verification covers it.

Notes

• Discrete by nature here: the roles are a per-sample state, so the block always steps at its own period. The Simulink block is continuous; at the same fixed step under its Euler solver the two agree exactly.
• Stateful: 9n controller states plus the two role machines. Direct feedthrough always: the weights are the Prelookup fraction of v at the same instant, so the output moves with v even with every D row zero.
• Every standby controller's state still evolves, fed the blended output, so it is ready when the roles rotate it in.
• In the three HDL targets v1 and v2 arrive in Q16.16, so a variable within one quantum (1.5×10⁻⁵) of a breakpoint can fall in the other interval, and its roles then rotate on a different sample than a double-precision run would. The blended output is continuous across a breakpoint, but the role machine is not, so treat a red HDL cell on this block as a re-run before a diagnosis.