rtint 0.0.3__py3-none-any.whl

rtint/rtint_filter.py

@@ -0,0 +1,872 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+"""
+REAL-TIME TARGET Signal filters
+"""
+
+import numpy as np
+from scipy.signal import dlti
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+class RtintHdwFilterController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._system = tg._system
+        self._program = tg._program
+        self._param_tree = self._program.tree.params
+
+        self._filters: dict[str, RtintHdwFilter] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._filters is None:
+            return "\n    No Filter in the model"
+
+        if debug:
+            lines = [["Name", "Path", "Type", "Parameters"]]
+        else:
+            lines = [["Name", "Type", "Parameters"]]
+        for _filter in self._filters.values():
+            if debug:
+                lines.append(
+                    [
+                        _filter._name,
+                        _filter._unique_name,
+                        _filter._type,
+                        ", ".join(parameter for parameter in _filter._filter_params),
+                    ]
+                )
+            else:
+                lines.append(
+                    [
+                        _filter._name,
+                        _filter._type,
+                        ", ".join(parameter for parameter in _filter._filter_params),
+                    ]
+                )
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        """Automatically discover all filters present in the model."""
+        filters = self._tg._get_all_objects_from_key("bliss_filter")
+        if len(filters) > 0:
+            self._filters = {}
+            for _filter in filters:
+                filter_type = self._tg.parameter.get(
+                    f"{_filter}/filter_type/String"
+                )
+
+                if filter_type == "biquad":
+                    tg_filter = RtintHdwBiquad(self._tg, _filter)
+                elif filter_type == "remove_dc":
+                    tg_filter = RtintRemoveDcFilter(self._tg, _filter)
+                elif filter_type == "general_fir":
+                    tg_filter = RtintGeneralFirFilter(self._tg, _filter)
+                elif filter_type == "general_iir":
+                    tg_filter = RtintGeneralIirFilter(self._tg, _filter)
+                elif filter_type == "pid":
+                    tg_filter = RtintPidFilter(self._tg, _filter)
+                elif filter_type == "signal_characteristics":
+                    tg_filter = RtintSignalCharacteristicsFilter(
+                        self._tg, _filter
+                    )
+                else:
+                    tg_filter = RtintHdwFilter(self._tg, _filter)
+
+                if hasattr(self, tg_filter._name):
+                    print(
+                        f"{RED}WARNING: Filter '{tg_filter._name}' already exists{RESET}"
+                    )
+                    return
+                else:
+                    setattr(self, tg_filter._name, tg_filter)
+                    self._filters[tg_filter._name] = tg_filter
+
+
+class RtintHdwFilter:
+    def __init__(self, tg, unique_name):
+        self._tg = tg
+        self._unique_name = unique_name
+        self._type = None
+        self._filter_params = []
+
+    def __info__(self):
+        return tabulate(
+            self._get_info_lines(), tablefmt="plain", stralign="right"
+        )
+
+    def _get_info_lines(self):
+        lines = []
+        lines.append(["Name", self._name])
+        lines.append(["Unique Name", self._unique_name])
+        lines.append(["", ""])
+        lines.append(["Type", self._type])
+        return lines
+
+    def _tree(self):
+        print("Parameters:")
+        self._tg.parameter._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+        print("Signals:")
+        self._tg.signal._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+
+    @property
+    def _name(self):
+        return self._tg.parameter.get(f"{self._unique_name}/bliss_filter/String")
+
+    @property
+    def input(self):
+        return self._tg.signal.get(f"{self._unique_name}/input")
+
+    @property
+    def output(self):
+        return self._tg.signal.get(f"{self._unique_name}/output")
+
+    def plot(
+        self,
+        f=None,
+        xlim_min=None,
+        xlim_max=None,
+        ylim_min=None,
+        ylim_max=None,
+        title=None,
+        directory=None,
+        file_name=None,
+    ):
+        self._tg.utils._bode_plot(
+            [self._get_transfer_function()],
+            f_exp=f,
+            xlim_min=xlim_min,
+            xlim_max=xlim_max,
+            ylim_min=ylim_min,
+            ylim_max=ylim_max,
+            title=title,
+            directory=directory,
+            file_name=file_name,
+        )
+
+
+class RtintHdwBiquad(RtintHdwFilter):
+    """Generic biquad IIR filter, runtime-configurable.
+
+    Implements: y[k] = b0*u[k] + b1*u[k-1] + b2*u[k-2] - a1*y[k-1] - a2*y[k-2]
+
+    Use the convenience methods (low_pass, high_pass, etc.) to compute and upload
+    Tustin-discretized coefficients, or write b0..b2, a1, a2 directly.
+    """
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._filter_params = ["b0", "b1", "b2", "a1", "a2"]
+        self._type = "Biquad"
+
+    def __info__(self):
+        lines = super()._get_info_lines()
+        lines.append(["", ""])
+        lines.append(["Parameters:", ""])
+        for param in self._filter_params:
+            lines.append([param, getattr(self, param)])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    @property
+    def b0(self):
+        return self._tg.parameter.get(f"{self._unique_name}/b0/Gain")
+
+    @property
+    def b1(self):
+        return self._tg.parameter.get(f"{self._unique_name}/b1/Gain")
+
+    @property
+    def b2(self):
+        return self._tg.parameter.get(f"{self._unique_name}/b2/Gain")
+
+    @property
+    def a1(self):
+        return self._tg.parameter.get(f"{self._unique_name}/a1/Gain")
+
+    @property
+    def a2(self):
+        return self._tg.parameter.get(f"{self._unique_name}/a2/Gain")
+
+    def _upload(self, b, a):
+        """Write [b0,b1,b2] and [1,a1,a2] to real-time target, then reset states."""
+        self._tg.parameter.set(f"{self._unique_name}/b0/Gain", b[0])
+        self._tg.parameter.set(f"{self._unique_name}/b1/Gain", b[1])
+        self._tg.parameter.set(f"{self._unique_name}/b2/Gain", b[2])
+        self._tg.parameter.set(f"{self._unique_name}/a1/Gain", a[1])
+        self._tg.parameter.set(f"{self._unique_name}/a2/Gain", a[2])
+        self.reset()
+
+    def reset(self):
+        """Increment reset_trigger to flush internal biquad states."""
+        reset_val = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset/Bias")
+        )
+        self._tg.parameter.set(f"{self._unique_name}/reset/Bias", reset_val + 1)
+
+    # ------------------------------------------------------------------
+    # Convenience methods — Tustin (bilinear) discretization
+    # ------------------------------------------------------------------
+
+    def low_pass(self, wn: float, xi: float = 0.707):
+        """Second-order low-pass: wn^2 / (s^2 + 2*xi*wn*s + wn^2)."""
+        dt = self._tg._Ts
+        d = dt**2 * wn**2 + 4 * xi * dt * wn + 4
+        b = np.array([dt**2 * wn**2, 2 * dt**2 * wn**2, dt**2 * wn**2]) / d
+        a = (
+            np.array(
+                [d, 2 * dt**2 * wn**2 - 8, dt**2 * wn**2 - 4 * xi * dt * wn + 4]
+            )
+            / d
+        )
+        self._upload(b, a)
+
+    def high_pass(self, wn: float, xi: float = 0.707):
+        """Second-order high-pass: s^2 / (s^2 + 2*xi*wn*s + wn^2)."""
+        dt = self._tg._Ts
+        d = dt**2 * wn**2 + 4 * xi * dt * wn + 4
+        b = np.array([4, -8, 4]) / d
+        a = (
+            np.array(
+                [d, 2 * dt**2 * wn**2 - 8, dt**2 * wn**2 - 4 * xi * dt * wn + 4]
+            )
+            / d
+        )
+        self._upload(b, a)
+
+    def first_order_low_pass(self, wn: float):
+        """First-order low-pass: wn / (s + wn)."""
+        dt = self._tg._Ts
+        d = dt * wn + 2
+        b = np.array([dt * wn / d, dt * wn / d, 0.0])
+        a = np.array([1.0, (dt * wn - 2) / d, 0.0])
+        self._upload(b, a)
+
+    def first_order_high_pass(self, wn: float):
+        """First-order high-pass: s / (s + wn)."""
+        dt = self._tg._Ts
+        d = dt * wn + 2
+        b = np.array([2 / d, -2 / d, 0.0])
+        a = np.array([1.0, (dt * wn - 2) / d, 0.0])
+        self._upload(b, a)
+
+    def notch(self, wn: float, xi: float, gc: float):
+        """Notch: (s^2 + 2*xi*gc*wn*s + wn^2) / (s^2 + 2*xi*wn*s + wn^2).
+
+        gc < 1 for attenuation, gc > 1 for amplification at wn.
+        """
+        dt = self._tg._Ts
+        d = dt**2 * wn**2 + 4 * xi * dt * wn + 4
+        b = (
+            np.array(
+                [
+                    dt**2 * wn**2 + 4 * gc * xi * dt * wn + 4,
+                    2 * dt**2 * wn**2 - 8,
+                    dt**2 * wn**2 - 4 * gc * xi * dt * wn + 4,
+                ]
+            )
+            / d
+        )
+        a = (
+            np.array(
+                [d, 2 * dt**2 * wn**2 - 8, dt**2 * wn**2 - 4 * xi * dt * wn + 4]
+            )
+            / d
+        )
+        self._upload(b, a)
+
+    def integrator(self):
+        """Tustin integrator: 1/s."""
+        dt = self._tg._Ts
+        b = np.array([dt / 2, dt / 2, 0.0])
+        a = np.array([1.0, -1.0, 0.0])
+        self._upload(b, a)
+
+    def passthrough(self):
+        """Pass-through: y[k] = u[k]."""
+        self._upload(np.array([1.0, 0.0, 0.0]), np.array([1.0, 0.0, 0.0]))
+
+    def zero(self):
+        """Zero output: y[k] = 0."""
+        self._upload(np.array([0.0, 0.0, 0.0]), np.array([1.0, 0.0, 0.0]))
+
+    def lead(self, wn: float, a: float):
+        """Lead filter: (s + wn) / (s + a*wn), a > 1."""
+        dt = self._tg._Ts
+        d = dt * a * wn + 2
+        b = np.array([(2 * a + dt * wn) / d, (dt * wn - 2 * a) / d, 0.0])
+        den = np.array([1.0, (dt * a * wn - 2) / d, 0.0])
+        self._upload(b, den)
+
+    def lag(self, wn: float, a: float):
+        """Lag filter, a < 1."""
+        dt = self._tg._Ts
+        d = dt * wn + 2 * a**0.5
+        b = np.array(
+            [(2 * a**0.5 + dt * a * wn) / d, (dt * a * wn - 2 * a**0.5) / d, 0.0]
+        )
+        den = np.array([1.0, (dt * wn - 2 * a**0.5) / d, 0.0])
+        self._upload(b, den)
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+        b = [self.b0, self.b1, self.b2]
+        a = [1.0, self.a1, self.a2]
+        return dlti(b, a, dt=dt)
+
+
+class RtintRemoveDcFilter(RtintHdwFilter):
+    """Filter that can be triggered to remove the DC part of the signal."""
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._type = "Remove DC"
+
+    @property
+    def offset(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_offset")
+
+    @offset.setter
+    def offset(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/offset", value)
+        except Exception:
+            print("offset is dynamically set within the real-time target")
+
+    def trigger(self):
+        trigger_value = int(
+            self._tg.parameter.get(f"{self._unique_name}/start_trigger/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/start_trigger/Bias", trigger_value + 1
+        )
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+
+        return dlti([1], [1], dt=dt)
+
+
+class RtintGeneralFirFilter(RtintHdwFilter):
+    """Finite Impulse Response (FIR) filter.
+
+    Implements:
+        y[k] = b0*u[k] + b1*u[k-1] + ... + bN*u[k-N]
+
+    Transfer function (z-domain):
+
+        H(z) = b0 + b1*z^-1 + ... + bN*z^-N
+
+    where num_coef = [b0, b1, ..., bN]. The denominator is implicitly
+    1 (all poles at z = 0), so every FIR filter is unconditionally stable.
+
+    Parameters
+    ----------
+    num_coef : array of numerator coefficients [b0, b1, ..., bN]
+               Length is fixed by the Simulink model (max_taps).
+               Coefficients beyond the desired order should be set to 0.
+    """
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._filter_params = ["order", "num_coef"]
+        self._type = "General FIR"
+        self._max_taps: int = self._tg._program.tree.signals[
+            f"{self._tg._program.name}/{self._unique_name}/param_num_coef"
+        ].shape[0]
+
+    def __info__(self):
+        lines = super()._get_info_lines()
+        lines.append(["", ""])
+        lines.append(["Parameters:", ""])
+        lines.append(["Order", self.order])
+        lines.append(["Max taps", self.max_taps])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    @property
+    def order(self):
+        return len(self.num_coef) - 1
+
+    @property
+    def max_taps(self) -> int:
+        return self._max_taps
+
+    def moving_average(self, avg_time: float):
+        dt = self._tg._Ts
+        n_taps = round(avg_time / dt)
+        max_avg_time = self._max_taps * dt
+        if n_taps > self._max_taps:
+            print(
+                f"{RED}WARNING: avg_time ({avg_time:.3f} s = {n_taps} taps) "
+                f"exceeds maximum ({max_avg_time:.3f} s = {self._max_taps} taps); "
+                f"clamping to maximum{RESET}"
+            )
+            n_taps = self._max_taps
+        coef = np.zeros(self._max_taps)
+        coef[:n_taps] = 1.0 / n_taps
+        self.num_coef = coef
+        self.reset()
+
+    @property
+    def num_coef(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_num_coef")
+
+    @num_coef.setter
+    def num_coef(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/num_coef", value)
+        except Exception:
+            print("num_coef is dynamically set within the real-time target")
+
+    def reset(self):
+        reset_states = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/reset/Bias", reset_states + 1
+        )
+
+    def passthrough(self):
+        """Pass-through: num_coef = [1, 0, ..., 0] at current length."""
+        n = len(self.num_coef)
+        coef = np.zeros(n)
+        coef[0] = 1.0
+        self.num_coef = coef
+        self.reset()
+
+    def zero(self):
+        """Zero output: num_coef = [0, ..., 0] at current length."""
+        n = len(self.num_coef)
+        self.num_coef = np.zeros(n)
+        self.reset()
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+
+        num = list(self.num_coef)
+        den = [1] + [0] * (len(num) - 1)
+        return dlti(num, den, dt=dt)
+
+
+class RtintGeneralIirFilter(RtintHdwFilter):
+    """Infinite Impulse Response (IIR) filter.
+
+    Implements:
+        y[k] = b0*u[k] + b1*u[k-1] + ... + bM*u[k-M]
+             - a1*y[k-1] - a2*y[k-2] - ... - aN*y[k-N]
+
+    Transfer function (z-domain):
+
+        H(z) = (b0 + b1*z^-1 + ... + bM*z^-M) / (1 + a1*z^-1 + ... + aN*z^-N)
+
+    where num_coef = [b0, b1, ..., bM] and den_coef = [1, a1, ..., aN].
+    den_coef[0] is always 1.0 (leading coefficient of the denominator).
+
+    Parameters
+    ----------
+    num_coef : array of numerator coefficients [b0, b1, ..., bM]
+    den_coef : array of denominator coefficients [1, a1, ..., aN]
+               (leading a0 = 1 is included as the first element)
+    """
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._filter_params = ["order", "num_coef", "den_coef"]
+        self._type = "General IIR"
+
+    def __info__(self):
+        lines = super()._get_info_lines()
+        lines.append(["", ""])
+        lines.append(["Parameters:", ""])
+        lines.append(["Order", self.order])
+        lines.append(
+            ["Numerator", "[" + ", ".join(f"{x:.2g}" for x in self.num_coef) + "]"]
+        )
+        lines.append(
+            ["Denominator", "[" + ", ".join(f"{x:.2g}" for x in self.den_coef) + "]"]
+        )
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    @property
+    def order(self):
+        return len(self.den_coef) - 1
+
+    @property
+    def num_coef(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_num_coef")
+
+    @num_coef.setter
+    def num_coef(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/num_coef", value)
+        except Exception:
+            print("num_coef is dynamically set within the real-time target")
+
+    @property
+    def den_coef(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_den_coef")
+
+    @den_coef.setter
+    def den_coef(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/den_coef", value)
+        except Exception:
+            print("den_coef is dynamically set within the real-time target")
+
+    def reset(self):
+        reset_states = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/reset/Bias", reset_states + 1
+        )
+
+    def passthrough(self):
+        """Pass-through: num_coef = [1, 0, ...], den_coef = [1, 0, ...]."""
+        n_num = len(self.num_coef)
+        n_den = len(self.den_coef)
+        num = np.zeros(n_num)
+        num[0] = 1.0
+        den = np.zeros(n_den)
+        den[0] = 1.0
+        self.num_coef = num
+        self.den_coef = den
+        self.reset()
+
+    def zero(self):
+        """Zero output: num_coef = [0, ...], den_coef = [1, 0, ...]."""
+        n_num = len(self.num_coef)
+        n_den = len(self.den_coef)
+        den = np.zeros(n_den)
+        den[0] = 1.0
+        self.num_coef = np.zeros(n_num)
+        self.den_coef = den
+        self.reset()
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+
+        return dlti(self.num_coef, self.den_coef, dt=dt)
+
+
+class RtintPidFilter(RtintHdwFilter):
+    """PID controller with 1st-order derivative low-pass filter.
+
+    Continuous-time transfer function (when fi > 0, fd > 0):
+
+        K_pid(s) = k * (1 + s/(2*pi*fd)) / (1 + s/(2*pi*ft)) * (1 + 2*pi*fi/s)
+
+    Discrete-time transfer function (z-domain):
+
+        K_pid(z) = ( kp  +  ki*Ts / (1 - z^-1)  +  kd/Ts * (1 - z^-1) ) * LPF(z)
+
+        where kp, ki, kd are computed by Simulink from k/f_i/f_d/f_t,
+        and LPF(z) is the bilinear discretisation of 1 / (1 + s/(2*pi*ft)).
+
+    Parameters
+    ----------
+    k   : overall gain
+    f_i : integrator corner frequency [Hz]  (set to 0 to disable integrator)
+    f_d : derivative corner frequency [Hz]:
+          - f_d > 0 : derivative enabled (standard PID behaviour)
+          - f_d = 0 : derivative disabled (PI or P controller)
+          - f_d < 0 : pure integrator mode (kp = 0, kd = 0)
+    f_t : low-pass corner frequency on derivative output [Hz]
+
+    The gain computation follows these rules:
+
+        ki = k * 2*pi*f_i   (if f_i > 0, else ki = 0)
+
+        f_d > 0 : kp = k * (1 + f_i/f_d),  kd = k / (2*pi*f_d)
+        f_d = 0 : kp = k,                  kd = 0
+        f_d < 0 : kp = 0,                  kd = 0
+
+    Common configurations:
+
+        | Config  | f_i | f_d | kp                      | ki          | kd            |
+        |---------|-----|-----|-------------------------|-------------|---------------|
+        | PID     | >0  | >0  | k*(1 + f_i/f_d)         | k*2*pi*f_i  | k/(2*pi*f_d)  |
+        | PI      | >0  | =0  | k                       | k*2*pi*f_i  | 0             |
+        | PD      | =0  | >0  | k*(1 + 0/f_d) = k       | 0           | k/(2*pi*f_d)  |
+        | P       | =0  | =0  | k                       | 0           | 0             |
+        | Pure I  | >0  | <0  | 0                       | k*2*pi*f_i  | 0             |
+    """
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._type = "PID"
+        self._filter_params = [
+            "k",
+            "f_i",
+            "f_d",
+            "f_t",
+            "enable_lpf",
+            "sat_upper",
+            "sat_lower",
+        ]
+
+    def __info__(self):
+        lines = super()._get_info_lines()
+        lines.append(["", ""])
+        lines.append(["Parameters:", ""])
+        lines.append(["k", self.k])
+        lines.append(["f_i", self.f_i])
+        lines.append(["f_d", self.f_d])
+        lines.append(["f_t", self.f_t])
+        lines.append(["enable_lpf", self.enable_lpf])
+        lines.append(["sat_upper", self.sat_upper])
+        lines.append(["sat_lower", self.sat_lower])
+        lines.append(["", ""])
+        lines.append(["Status:", ""])
+        sat_str = f"{RED}True{RESET}" if self.saturated else f"{GREEN}True{RESET}"
+        lines.append(["saturated", sat_str])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    # --- Ground-truth parameters (direct R/W hardware access) ---
+
+    @property
+    def k(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_k")
+
+    @k.setter
+    def k(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/k", value)
+        except Exception:
+            print("k is dynamically set within the real-time target")
+
+    @property
+    def f_i(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_fi")
+
+    @f_i.setter
+    def f_i(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/fi", value)
+        except Exception:
+            print("f_i is dynamically set within the real-time target")
+
+    @property
+    def f_d(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_fd")
+
+    @f_d.setter
+    def f_d(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/fd", value)
+        except Exception:
+            print("f_d is dynamically set within the real-time target")
+
+    @property
+    def f_t(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_ft")
+
+    @f_t.setter
+    def f_t(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/ft", value)
+        except Exception:
+            print("f_t is dynamically set within the real-time target")
+
+    @property
+    def enable_lpf(self):
+        return int(
+            self._tg.parameter.get(f"{self._unique_name}/enable_lpf/Value")
+        )
+
+    @enable_lpf.setter
+    def enable_lpf(self, value):
+        try:
+            self._tg.parameter.set(
+                f"{self._unique_name}/enable_lpf/Value", int(value)
+            )
+        except Exception:
+            print("enable_lpf is dynamically set within the real-time target")
+
+    # --- Private read-only signals (computed by Simulink) ---
+
+    @property
+    def _kp(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_kp")
+
+    @property
+    def _ki(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_ki")
+
+    @property
+    def _kd(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_kd")
+
+    # --- Saturation limits ---
+
+    @property
+    def sat_upper(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_sat_upper")
+
+    @sat_upper.setter
+    def sat_upper(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/sat_upper", value)
+        except Exception:
+            print("sat_upper is dynamically set within the real-time target")
+
+    @property
+    def sat_lower(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_sat_lower")
+
+    @sat_lower.setter
+    def sat_lower(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/sat_lower", value)
+        except Exception:
+            print("sat_lower is dynamically set within the real-time target")
+
+    # --- Read-only status ---
+
+    @property
+    def saturated(self):
+        return bool(self._tg.signal.get(f"{self._unique_name}/saturated"))
+
+    # --- Reset ---
+
+    def reset(self):
+        reset_states = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/reset/Bias", reset_states + 1
+        )
+
+    def passthrough(self):
+        """Pass-through: k=1, f_i=0, f_d=0, LPF disabled.
+
+        With the LPF disabled, the TF is exactly 1 (no approximation).
+        """
+        self.k = 1.0
+        self.f_i = 0.0
+        self.f_d = 0.0
+        self.enable_lpf = 0
+        self.reset()
+
+    def zero(self):
+        """Zero output: k=0 → kp=ki=kd=0 → TF = 0."""
+        self.k = 0.0
+        self.reset()
+
+    # --- Transfer function ---
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+
+        kp = self._kp
+        ki = self._ki
+        kd = self._kd
+        f_t = self.f_t
+
+        # P + I(Forward Euler) + D(Backward Euler), common denominator z(z-1):
+        # P → kp·z(z-1),  I → ki·Ts·z²,  D → kd/Ts·(z-1)²
+        # num = (kp + ki·Ts + kd/Ts)·z² + (-kp - 2·kd/Ts)·z + kd/Ts
+        pid_num = np.array(
+            [
+                kp + ki * dt + kd / dt,
+                -kp - 2 * kd / dt,
+                kd / dt,
+            ]
+        )
+        pid_den = np.array([1, -1, 0])  # z(z-1)
+
+        # LP filter (Tustin): (z + 1) / ((1+alpha)*z + (1-alpha))
+        # alpha = 1/(pi*f_t*Ts);  skipped when LPF is disabled (enable_lpf = 0)
+        if self.enable_lpf:
+            alpha = 1 / (np.pi * f_t * dt)
+            lp_num = np.array([1, 1])
+            lp_den = np.array([1 + alpha, 1 - alpha])
+            num = np.polymul(pid_num, lp_num)
+            den = np.polymul(pid_den, lp_den)
+        else:
+            num = pid_num
+            den = pid_den
+
+        return dlti(num, den, dt=dt)
+
+
+class RtintSignalCharacteristicsFilter(RtintHdwFilter):
+    """Signal characteristics filter: computes running mean, variance and std.
+
+    Discrete-time transfer function (input -> mean, Forward Euler):
+
+        H(z) = (Ts/tau) / (1 - (1 - Ts/tau) * z^-1)
+
+    Signals
+    -------
+    signal_value : input signal (raw)
+    mean         : running mean (= output)
+    variance     : running variance
+    std          : running standard deviation
+
+    Parameters
+    ----------
+    time_constant : averaging time constant tau [s]
+    """
+
+    def __init__(self, tg, unique_name):
+        super().__init__(tg, unique_name)
+        self._type = "Signal Characteristics"
+        self._filter_params = ["time_constant"]
+
+    def __info__(self):
+        lines = super()._get_info_lines()
+        lines.append(["", ""])
+        lines.append(["Parameters:", ""])
+        lines.append(["time_constant", self.time_constant])
+        lines.append(["", ""])
+        lines.append(["Signals:", ""])
+        lines.append(["mean", self.mean])
+        lines.append(["variance", self.variance])
+        lines.append(["std", self.std])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    @property
+    def time_constant(self):
+        return self._tg.signal.get(f"{self._unique_name}/param_time_constant")
+
+    @time_constant.setter
+    def time_constant(self, value):
+        try:
+            self._tg.parameter.set(f"{self._unique_name}/time_constant", value)
+        except Exception:
+            print("time_constant is dynamically set within the real-time target")
+
+    @property
+    def mean(self):
+        return self._tg.signal.get(f"{self._unique_name}/output")
+
+    @property
+    def signal_value(self):
+        return self._tg.signal.get(f"{self._unique_name}/input")
+
+    @property
+    def variance(self):
+        return self._tg.signal.get(f"{self._unique_name}/signal_variance")
+
+    @property
+    def std(self):
+        return self._tg.signal.get(f"{self._unique_name}/signal_std")
+
+    def _get_transfer_function(self):
+        dt = self._tg._Ts
+        tau = self.time_constant
+        alpha = dt / tau
+        num = [alpha, 0]
+        den = [1, -(1 - alpha)]
+        return dlti(num, den, dt=dt)