Custom Interface Class: Calibratable

[Bilchreis]

I implemented a class that extends the drivable class for the ROCK-IT gas dosing system. This allows me to calibrate mass flow controllers (MFCs), pressure controllers and temperature controllers.

The SECoP spec does not mention custom interface classes; it simply states that the ECS should select the first or highest one it recognises:

The module class is in fact a list of classes (highest level class first) and is stored in the module-property interface_classes. The ECS chooses the first class from the list which is known to it. The last one in the list must be one of the base classes listed below.

Can I introduce a custom interface class like _Calibratable or would this be invalid SECoP? Im not sure if the functionality could also be added as a custom feature. Again the spec does not explicitly state that custom features are allowed.

Has the whole calibration topic been extensively discussed prior to this? Im not sure if it is possible to find a generic solution that fits all use cases. The solution presented below just fits the requirements we had for the project.

Below is the Frappy specific implementation:

import functools

import numpy as np
from frappy.core import ArrayOf, Drivable, FloatRange, PersistentMixin, PersistentParam, Parameter


class Calibratable(Drivable, PersistentMixin):

    inverse_calibration_coefficients = PersistentParam(
        "Inverse calibration polynomial coefficients for value Parameter",
        datatype=ArrayOf(FloatRange(-1000000, 100000), minlen=2, maxlen=5),
        default=[0, 1, 0],
        readonly=False,
        persistent="auto",
    )

    forward_calibration_coefficients = PersistentParam(
        "Forward calibration polynomial coefficients for target Parameter",
        datatype=ArrayOf(FloatRange(-1000000, 100000), minlen=2, maxlen=5),
        default=[0, 1, 0],
        readonly=False,
        persistent="auto",
    )

    value_uncalibrated = Parameter(
        "uncalibrated readback directly from the hardware",
        datatype=FloatRange(),
        default=0,
        readonly=True,
    )

    target_calibrated = Parameter(
        "calibrated target that is written to the hardware",
        datatype=FloatRange(),
        default=0,
        readonly=True,
    )

    def write_inverse_calibration_coefficients(self, value):
        self.inverse_calibration_coefficients = value
        self.saveParameters()
        return value

    def write_forward_calibration_coefficients(self, value):
        self.forward_calibration_coefficients = value
        self.saveParameters()
        return value

    def read_inverse_calibration_coefficients(self):
        return self.inverse_calibration_coefficients

    def read_forward_calibration_coefficients(self):
        return self.forward_calibration_coefficients

    def read_target_calibrated(self):
        return self.target_calibrated

    def read_value_uncalibrated(self):
        return self.value_uncalibrated

    def initModule(self):
        super().initModule()

        self.loadParameters()


def calibrate_setpoint(func):

    @functools.wraps(func)
    def wrapper(self: Calibratable, setpoint):

        # the setpoint is calculated through forward calibration polynomials
        # coefficient list is reversed, np.polyval expects highest degree first
        coeff = self.forward_calibration_coefficients[::-1]

        calibrated_setpoint = np.polyval(coeff, setpoint)
        self.target_calibrated = calibrated_setpoint

        func(self, calibrated_setpoint)

        return setpoint

    return wrapper


def calibrate_reading(func):

    @functools.wraps(func)
    def wrapper(self: Calibratable):

        raw_reading = func(self)

        self.value_uncalibrated = raw_reading

        # readback if going through inverse calibration
        # coefficient list is reversed, np.polyval expects highest degree first
        coeff = self.inverse_calibration_coefficients[::-1]

        return np.polyval(coeff, raw_reading)

    return wrapper    

In the actual Hardware drive one would just call the read_value() and write_target() functions with its according decorator:

    @calibrate_reading
    def read_value(self):
        return self.device.read()
 

    @calibrate_setpoint
    def write_target(self, value):
        self.device.set(value)
        self.status = self.Status.BUSY, "new setpoint set"

        return value

[markus-zolliker]

nice!

I think nothing speaks against declaring custom interface classes, also I think custom features should be allowed.
In frappy, I have this week modified the setting of the interface_class property:

https://forge.frm2.tum.de/review/c/secop/frappy/+/37728

Now you can just do:

class Calibratable(Drivable, PersistentMixin):
    interface_class = ['_Calibratable', 'Drivable']
    ...

You are not bound to have exactly the same name in the interface class as in for the python class.

[Bilchreis]

Ah nice! I had to overwrite the interface class in the initModule() call until now.

Ill use it as a custom interface class for now.