Flywheel Energy Storage Control

Overview

This chapter presents compact, implementation-oriented dynamic models for each stage of a multi-stage Flywheel Energy Storage System (FESS): rotor mechanics, magnetic bearings, power-electronics interface, and grid-coupling controller. Use these models when developing controller software, co-simulation drivers (e.g., FMI/Functional Mock-up Units), or digital twins for isolated mini-grids where sub-second response and high cyclic duty (10-100 Hz control loops) are required.

Quick Reference

• Rotor mechanical model: nonlinear inertia + viscous damping, state vector [ω, θ].
• Bearing dynamics: second-order linear model with stiffness Kb (N/m) and damping Cb (N·s/m).
• Power electronics: averaged DC-link model with switching-frequency losses; key parameter fsw (kHz).
• Grid interface: cascaded current/voltage PI controllers with feedforward droop Rf (Ω) for 50 Hz islanded mini-grids.
• Typical numeric values: J = 12.5 kg·m², B = 0.08 N·m·s, Kb = 1.2e6 N/m, fsw = 8 kHz.

Parameters

Code Example

# Python: simple time-step integrator for rotor + inverter averaged model
import numpy as np

# Parameters (example values for an islanded mini-grid)
J = 12.5        # kg·m^2
B = 0.08        # N·m·s
Kb = 1.2e6      # N/m (bearing stiffness, magnetic)
Cb = 150        # N·s/m
fsw = 8e3       # Hz
Vdc = 750.0     # V
Rf = 0.02       # virtual droop ohms
Ts = 1e-4       # s sample time

# States
omega = 314.16   # rad/s (50 Hz electrical equivalent)
theta = 0.0      # rad
bearing_disp = 1e-5  # m small rotor offset

def mech_step(omega, theta, torque_e, torque_load, dt):
    # Rotor dynamics: J * dω/dt = torque_e - torque_load - B*ω
    domega = (torque_e - torque_load - B*omega) / J
    omega_new = omega + domega*dt
    theta_new = theta + omega_new*dt
    return omega_new, theta_new

def bearing_force(disp, vel):
    # Linearized bearing: F = -Kb*x - Cb*xdot
    return -Kb*disp - Cb*vel

# Example control action: convert DC power command to electromagnetic torque
def electromech_torque(P_cmd, omega):
    # Avoid division by zero, clamp omega
    omega_eff = max(omega, 1.0)
    return P_cmd / omega_eff

# Simulation step
P_cmd = 50000.0  # 50 kW charge/discharge command
torque_e = electromech_torque(P_cmd, omega)
torque_load = 0.0  # step event can assign nonzero
omega, theta = mech_step(omega, theta, torque_e, torque_load, Ts)
# bearing reaction (example numeric)
F_b = bearing_force(bearing_disp, 0.0)

Response Format

Expected structure when querying a simulation API or component model:

{
  "timestamp": 1616161616.0,    // float, Unix time
  "state": {
    "omega": 314.16,           // rad/s
    "theta": 1.234,            // rad
    "bearing_disp": 1e-5       // m
  },
  "outputs": {
    "torque_e": 159.2,         // N·m electromagnetic torque
    "dc_link": 748.5,          // V DC link voltage
    "p_out": 50000.0           // W delivered (positive discharge)
  },
  "warnings": []               // list of strings, e.g., ["overspeed"] 
}

Field descriptions: timestamp (simulation time), state (primary dynamic states), outputs (observable control outputs), warnings (runtime conditions).

Notes & Best Practices

• Numerical stiffness: rotor + bearing stiffness can be stiff-use implicit solvers or Ts ≤ 1e-4 s for explicit Euler/RK4; otherwise the bearing Kb=1.2e6 will force tiny steps.
• Measurement noise: high-speed sensors (e.g., encoder, Hall) introduce jitter at ±0.01%-filter carefully to avoid phase lag in inner loops.
• Edge case: during abrupt grid loss, clamp torque commands and implement mechanical braking to prevent overspeed beyond safe margin (e.g., 1.2× nominal ω).
• Validation: use hardware-in-the-loop (HIL) with an Opal-RT or Typhoon HIL instance and the example numeric set (J,B,fsw) to reproduce realistic transient behavior.