Fixed-Step Solver | Dynamics, Stability, and Control

Why this matters

The timestep becomes part of the system

Fixed-step solvers are used when the simulation must update at a known rate. This is common in flight software, digital control, real-time simulation, hardware-in-the-loop testing, and embedded control systems.

The danger is that a fixed-step method does not automatically reduce the timestep when the dynamics become fast, sensitive, or oscillatory. The engineer chooses \(\Delta t\), and that choice affects the behaviour of the simulated system.

Core warning: A fixed timestep turns continuous physics into a sampled system. If the sampling is too slow, the simulation can create false damping, false oscillation, false instability, or false frequency content.

Problem roadmap

One problem, six fixed-step lessons

A · Missing \(\omega\)
A discrete update fails when angle is not advanced using angular velocity.

B · Euler vs reality
Forward Euler is compared against the analytical rotational response.

C · Discrete PD control
A digital controller updates torque only at sampled time instants.

D · Stability vs timestep
The same gains are tested across \(\Delta t\) to find the stability boundary.

E · Numerical instability
Large timestep creates energy growth even when the model and controller are unchanged.

F · Chaser control
The same sampled-data issue appears in a simple relative-motion GNC example.

Part A

Missing \(\omega\): discrete update error

In rotational motion, angle must be advanced using angular velocity. The fixed-step update is:

\theta_{k+1}=\theta_k+\omega_k\Delta t

A common discrete mistake is to keep the angle unchanged, or to update it without the correct angular velocity term. The simulation may still run, but the physics is broken.

Initial angle \(\theta_0\)

Angular velocity \(\omega\)

Timestep \(\Delta t\)

Simulation time

Correct final θ—

Wrong final θ—

Final mismatch—

Main lessonState update

Part B

Euler integration vs reality

For constant torque, the rotational dynamics are:

I\dot{\omega}=\tau,\qquad \dot{\theta}=\omega

Forward Euler uses straight-line updates. With a small timestep it can look close to the analytical result. With a large timestep, it visibly drifts.

\omega_{k+1}=\omega_k+\frac{\tau}{I}\Delta t,\qquad \theta_{k+1}=\theta_k+\omega_k\Delta t

Inertia \(I\)

Torque \(\tau\)

Euler timestep

Simulation time

Final Euler θ—

Final analytical θ—

Final error—

Interpretation—

Part C

PD controller in discrete time

A digital controller does not react continuously. It samples the state, computes a torque, then holds that torque until the next update.

\tau_k=-K_p\theta_k-K_d\omega_k

\omega_{k+1}=\omega_k+\frac{\tau_k}{I}\Delta t,\qquad \theta_{k+1}=\theta_k+\omega_k\Delta t

Inertia \(I\)

Controller timestep

Initial angle \(\theta_0\)

Initial angular velocity \(\omega_0\)

Simulation time

Classification—

Peak |θ|—

Final |θ|—

Torque styleSampled

Part D

Stability boundary: same gains, different timestep

This is the key fixed-step lesson. Keep \(K_p\) and \(K_d\) fixed, then sweep \(\Delta t\). The controller did not change, the model did not change, but the sampled simulation can move from stable to oscillatory to unstable.

Insight: Stability is not only a function of gains. It is also a function of timestep.

Fixed Kp

Fixed Kd

Minimum \(\Delta t\)

Maximum \(\Delta t\)

Stable Oscillatory Unstable

Δt sample	Behaviour	Peak \|θ\|

Part E

Numerical instability caused by timestep

The equations do not change. The controller does not change. Only the timestep changes. If the coarse-step result grows energy while the fine-step result decays, the instability is numerical rather than physical.

Fine timestep

Coarse timestep

Engineering message: In fixed-step simulation, timestep is not housekeeping. It is a design decision.

Upgrade 2

Phase lag due to timestep

A sampled controller waits until the next update before reacting. The torque therefore appears as a stair-step signal. As \(\Delta t\) increases, the control action becomes more delayed. Delay behaves like additional phase lag in a control system.

Sampling timestep

0.0050.1200.35

Simulation time

Sampling rate—

Approx delay—

Torque signalStair-step

Control effectPhase lag

Upgrade 3

Aliasing: seeing the wrong dynamics

If a fast oscillation is sampled too slowly, the sampled points can appear to represent a different, slower frequency. This is aliasing. In engineering simulation, aliasing can make the system appear to have dynamics that are not actually present.

x(t)=\sin(2\pi f t),\qquad f_s=\frac{1}{\Delta t}

\text{Aliasing risk when}\qquad f_s<2f

True frequency \(f\) [Hz]

Sampling timestep \(\Delta t\)

Signal duration

Sampling frequency—

Nyquist limit—

Aliasing status—

Perceived frequency—

Industry-level insight: If the timestep is too large, the system can “see” the wrong dynamics.

Part F

Chaser control: discrete GNC example

A chaser approaches a target using a sampled PD-like controller. The relative-motion model is intentionally simple so the timestep effect is easy to see.

\ddot{x}=\frac{u}{m},\qquad u_k=-K_p(x_k-x_{target})-K_dv_k

v_{k+1}=v_k+\frac{u_k}{m}\Delta t,\qquad x_{k+1}=x_k+v_k\Delta t

Initial relative position \(x_0\)

Initial relative velocity \(v_0\)

Mass

Controller timestep

Simulation time

Mission insight: A chaser can fail not because the guidance law is conceptually wrong, but because the update rate is too slow for the closed-loop dynamics.

Python / MATLAB snippets

Fixed-step code blocks

These snippets mirror the page logic. Keep them short so the reader can connect each code block to one specific engineering idea.

# Fixed-step rotational PD controller
import numpy as np
import matplotlib.pyplot as plt

Kp = 20.0
Kd = 4.0
I = 1.0
dt = 0.05
t_final = 8.0

theta = 1.0
omega = 0.0

T = np.arange(0, t_final + dt, dt)
TH = []
OM = []
TAU = []

for t in T:
    tau = -Kp*theta - Kd*omega
    TH.append(theta)
    OM.append(omega)
    TAU.append(tau)

    omega = omega + (tau/I)*dt
    theta = theta + omega*dt

plt.plot(T, TH, label='theta')
plt.step(T, TAU, where='post', label='sampled torque')
plt.grid(True)
plt.legend()
plt.show()

% Fixed-step Euler simulation for attitude control
Kp = 20;
Kd = 4;
I  = 1;
dt = 0.05;
tf = 8;

T = 0:dt:tf;
theta = zeros(size(T));
omega = zeros(size(T));
tau = zeros(size(T));

theta(1) = 1;
omega(1) = 0;

for k = 1:length(T)-1
    tau(k) = -Kp*theta(k) - Kd*omega(k);
    omega(k+1) = omega(k) + (tau(k)/I)*dt;
    theta(k+1) = theta(k) + omega(k+1)*dt;
end

figure;
plot(T, theta, 'LineWidth', 1.8); hold on;
stairs(T, tau, '--', 'LineWidth', 1.2);
grid on;
xlabel('Time [s]');
ylabel('Response');
legend('theta', 'sampled torque');
title('Fixed-step discrete-time PD response');

# Aliasing demo
import numpy as np
import matplotlib.pyplot as plt

f = 6.0          # true frequency [Hz]
dt = 0.13       # sampling timestep [s]
tf = 2.0

fs = 1/dt
print('Sampling frequency:', fs)
print('Nyquist frequency:', fs/2)

fine_t = np.linspace(0, tf, 3000)
sample_t = np.arange(0, tf + dt, dt)

x_true = np.sin(2*np.pi*f*fine_t)
x_sample = np.sin(2*np.pi*f*sample_t)

plt.plot(fine_t, x_true, label='true signal')
plt.plot(sample_t, x_sample, 'o--', label='sampled signal')
plt.grid(True)
plt.legend()
plt.show()

Teaching note: These examples intentionally use fixed-step updates. The purpose is not to make the most accurate solver; the purpose is to show how timestep changes the simulated behaviour.

Engineering takeaway

Fixed-step simulation is powerful, but timestep is a design choice

1 · The model can be correct

The equations may represent the real physics, but the discrete update can still distort the response.

2 · The controller is sampled

A digital controller only reacts at update instants, so the torque naturally includes delay and phase lag.

3 · Sampling can lie

If the timestep is too large, aliasing can make fast dynamics appear as a different slower motion.

Final insight: For GNC, choosing \(\Delta t\) is not housekeeping. It is part of the engineering design.

← Back to Problem Bank