Fixed Point State Space — Control Systems/Discrete

Fixed-Point State-Space

Control Systems / Discrete

A MIMO discrete-time linear system whose matrices are given already discrete – there is no continuous original behind them:

y[k] = C·x[k] + D·u[k]
x[k+1] = A·x[k] + B·u[k]

with n states, m inputs and p outputs, so A is [n,n], B is [n,m], C is [p,n] and D is [p,m]. The output is taken from the state before the update, so the block has direct feedthrough only through D.

Ports

• Input – the input vector u, [m,1], sized from the column count of B and D. The block is genuinely MIMO: the vector is the signal, and the system is not replicated per entry.
• Output – the output vector y, [p,1], sized from the row count of C.

Parameters

• A – the [n,n] discrete state matrix. Its eigenvalues are z-plane poles: the system is stable when all of them lie inside the unit circle.
• B – the [n,m] input matrix; its column count sets the input port width.
• C – the [p,n] output matrix; its row count sets the output port width.
• D – the [p,m] direct feedthrough matrix.
• Initial Condition – the state at the start of the run. A scalar seeds every state with that value (Simulink's default form); an [n,1] vector seeds them individually.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. Nothing is discretized on the way out – the matrices are already discrete, so every target realizes the very recursion the simulation runs. A, B, C and D are baked into the generated body as constants rather than exposed as tunable parameters, because changing their dimensions would change the size of the state array the core declares. The three HDL targets carry the recursion in Q16.16 fixed point, like every other discrete block here.

Simulink bridge

Import and export, mapped to simulink/Additional Math & Discrete/ Additional Discrete/Fixed-Point State-Space. "A", "B", "C" and "D" to A, B, C, D, and "Initial Condition" to InitialCondition, all as plain pass-through values, so the round trip is lossless.

The Simulink block's fixed-point machinery has no ICore choice behind it and is always written out fixed: InternalDataType as fixdt('double'), which is what makes Simulink's arithmetic double precision and therefore comparable with ICore's at all; StateEqScaling and OutputEqScaling as 2^0, and LockScale off, RndMeth Floor, DoSatur off – every one of which acts on a fixed-point stored type that a double-precision block does not have. "Sampling Time (s)" does NOT cross: this Simulink block defines no SampleTime parameter at all, so the rate stays on the ICore side and a block given an explicit period reports that it did not cross.

Notes

• Discrete only, and stateful: the state is the [n,1] vector x.
• No continuous state space is carried, because the matrices are z-domain and there is nothing to recover one from. The model-reduction commands therefore report the block as unmergeable, which is the honest answer – use Discrete State Space when the system does have a continuous original to state.