biosignal-device-interface 0.1.11b0__py3-none-any.whl → 0.1.32a1__py3-none-any.whl

biosignal_device_interface/__init__.py

@@ -1,4 +0,0 @@
-from biosignal_device_interface.devices import otb
-from biosignal_device_interface.constants.devices.core.base_device_constants import (
-    DeviceType,
-)

biosignal_device_interface/constants/devices/__init__.py

@@ -0,0 +1,3 @@
+from biosignal_device_interface.constants.devices.core.base_device_constants import (
+    DeviceType,
+)

biosignal_device_interface/constants/devices/core/base_device_constants.py

@@ -16,9 +16,11 @@ class DeviceType(Enum):
     """
 
     _init_ = "value __doc__"
+    OTB_QUATTROCENTO = auto(), "OT Bioelettronica Quattrocento"
     OTB_QUATTROCENTO_LIGHT = auto(), "OT Bioelettronica Quattrocento Light"
     OTB_MUOVI = auto(), "OT Bioelettronica Muovi"
     OTB_MUOVI_PLUS = auto(), "OT Bioelettronica Muovi Plus"
+    OTB_SYNCSTATION = auto(), "OT Bioelettronica SyncStation"
 
 
 class OTBDeviceType(Enum):
@@ -27,9 +29,13 @@ class OTBDeviceType(Enum):
     Add new devices here.
     """
 
+    _init_ = "value __doc__"
+
+    QUATTROCENTO = auto(), "Quattrocento"
     QUATTROCENTO_LIGHT = auto(), "Quattrocento Light"
     MUOVI = auto(), "Muovi"
     MUOVI_PLUS = auto(), "Muovi Plus"
+    SYNCSTATION = auto(), "SyncStation"
 
 
 class DeviceChannelTypes(Enum):
@@ -42,10 +48,14 @@ class DeviceChannelTypes(Enum):
 
 ############# CONSTANTS #############
 DEVICE_NAME_DICT: dict[DeviceType | OTBDeviceType, str] = {
+    DeviceType.OTB_QUATTROCENTO: "Quattrocento",
+    OTBDeviceType.QUATTROCENTO: "Quattrocento",
     DeviceType.OTB_QUATTROCENTO_LIGHT: "Quattrocento Light",
     OTBDeviceType.QUATTROCENTO_LIGHT: "Quattrocento Light",
     DeviceType.OTB_MUOVI: "Muovi",
     OTBDeviceType.MUOVI: "Muovi",
     DeviceType.OTB_MUOVI_PLUS: "Muovi Plus",
     OTBDeviceType.MUOVI_PLUS: "Muovi Plus",
+    DeviceType.OTB_SYNCSTATION: "SyncStation",
+    OTBDeviceType.SYNCSTATION: "SyncStation",
 }

biosignal_device_interface/constants/devices/otb/otb_quattrocento_constants.py

@@ -1,17 +1,78 @@
 from aenum import Enum, auto
 
+"""
+Quattrocento constants.
+
+Developer: Dominik I. Braun
+Contact: dome.braun@fau.de
+Last Update: 2025-01-14
+"""
+
+
+# ------- Command Byte Sequences --------
+class QuattrocentoCommandSequence(Enum):
+    """
+    Enum class for the different kind of command sequences.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = auto(), "None"
+    ACQ_SETT = auto(), "Acquisition settings command sequence"
+    AN_OUT_IN_SEL = auto(), "Select input source and gain for the analog output"
+    AN_OUT_CH_SEL = auto(), "Select the channel for the analog output source"
+    IN_CONF = auto(), (
+        "Configuration command sequence for the eight IN inputs or",
+        "configuration for the four MULTIPLE IN inputs",
+    )
+    CRC = auto(), "Configuration command sequence byte (8 bits)"
+
+
+# ------------ ACQ_SETT BYTE ------------
+# Bit 7 is fixed to 1.
+
+
+class QuattrocentoDecimMode(Enum):
+    """
+    Enum class for the decimation bit of the Quattrocento device.
+    """
+
+    _init_ = "value __doc__"
+
+    INACTIVE = auto(), (
+        "Inactive. No decimation. The required sampling",
+        "frequency is obtained by sampling the signals",
+        "directly at the desired sampling frequency ",
+    )
+    ACTIVE = auto(), (
+        "Active. Decimation active.",
+        "The required sampling frequency is obtained by",
+        "sampling all the signals at 10240 Hz and then",
+        "sending one sample out of 2, 5 or 20, to obtain",
+        "the desired number of sample per second.",
+    )
+
+
+class QuattrocentoRecordingMode(Enum):
+    """
+    Enum class for the recording bit.
+
+    If the Trigger OUT has to be used to synchronize the acquisition with
+    other instruments, the recording has to be started when the trigger
+    channel has a transition. In other words it is the quattrocento that
+    generate a signal indicating to the computer when the data has to be
+    recorded.
+    """
 
-# Quattrocento Light constants
-############# COMMANDS #############
-COMMAND_START_STREAMING = b"startTX"
-COMMAND_STOP_STREAMING = b"stopTX"
-CONNECTION_RESPONSE = b"OTBioLab"
+    _init_ = "value __doc__"
+
+    STOP = auto(), "Stop"
+    START = auto(), "Start"
 
 
-############# QUATTROCENTO LIGHT #############
-class QuattrocentoLightSamplingFrequency(Enum):
+class QuattrocentoSamplingFrequencyMode(Enum):
     """
-    Enum class for the sampling frequencies of the Quattrocento Light device.
+    Enum class for the sampling frequencies of the Quattrocento device (2 bits).
     """
 
     _init_ = "value __doc__"
@@ -22,38 +83,231 @@ class QuattrocentoLightSamplingFrequency(Enum):
     ULTRA = auto(), "10240 Hz"
 
 
-class QuattrocentoLightStreamingFrequency(Enum):
+class QuattrocentoNumberOfChannelsMode(Enum):
     """
-    Enum class for the streaming frequencies of the Quattrocento Light device.
+    Enum class for the number of channels of the Quattrocento device (2 bits).
     """
 
     _init_ = "value __doc__"
 
-    ONE = auto(), "1 Hz"
-    TWO = auto(), "2 Hz"
-    FOUR = auto(), "4 Hz"
-    EIGHT = auto(), "8 Hz"
-    SIXTEEN = auto(), "16 Hz"
-    THIRTYTWO = auto(), "32 Hz"
+    LOW = auto(), "IN1, IN2 and MULTIPLE_IN1 are active."
+    MEDIUM = auto(), "IN1-IN4, MULTIPLE_IN1, MULTIPLE_IN2 are active."
+    HIGH = auto(), "IN1-IN6, MULTIPLE_IN1-MULTIPLE_IN2 are active."
+    ULTRA = auto(), "IN1-IN8, MULTIPLE_IN1-MULTIPLE_IN4 are active."
 
 
-QUATTROCENTO_SAMPLING_FREQUENCY_DICT: dict[QuattrocentoLightSamplingFrequency, int] = {
-    QuattrocentoLightSamplingFrequency.LOW: 512,
-    QuattrocentoLightSamplingFrequency.MEDIUM: 2048,
-    QuattrocentoLightSamplingFrequency.HIGH: 5120,
-    QuattrocentoLightSamplingFrequency.ULTRA: 10240,
-}
-"""
-Dictionary to get sampling frequency for each mode.
-"""
+class QuattrocentoAcquisitionMode(Enum):
+    """
+    Enum class for the acquisition bit.
+    """
+
+    _init_ = "value __doc__"
+
+    INACTIVE = auto(), "Inactive. Data sampling and transfer is not active"
+    ACTIVE = auto(), "Active. Data sampling and transfer is active"
+
+
+class QuattrocentoAcqSettByte:
+    """
+    Class for the acquisition settings byte of the Quattrocento device.
+    """
+
+    def __init__(self):
+        self._decimation_mode: QuattrocentoDecimMode = None
+        self._recording_mode: QuattrocentoRecordingMode = None
+        self._sampling_frequency_mode: QuattrocentoSamplingFrequencyMode = None
+        self._sampling_frequency: int = None
+        self._number_of_channels_mode: QuattrocentoNumberOfChannelsMode = None
+        self._number_of_channels: int = None
+        self._acquisition_mode: QuattrocentoAcquisitionMode = (
+            QuattrocentoAcquisitionMode
+        ).INACTIVE
+
+    def update(
+        self,
+        decimation_mode: QuattrocentoDecimMode,
+        recording_mode: QuattrocentoRecordingMode,
+        sampling_frequency_mode: QuattrocentoSamplingFrequencyMode,
+        number_of_channels_mode: QuattrocentoNumberOfChannelsMode,
+    ):
+        self._decimation_mode = decimation_mode
+        self._recording_mode = recording_mode
+        self._sampling_frequency_mode = sampling_frequency_mode
+        self._number_of_channels_mode = number_of_channels_mode
+
+        self._configure()
+
+    def _configure(self):
+        self._set_sampling_frequency()
+        self._set_number_of_channels()
+
+    def _set_sampling_frequency(self) -> None:
+        mode = self._sampling_frequency_mode
+        match mode:
+            case QuattrocentoSamplingFrequencyMode.LOW:
+                self._sampling_frequency = 512
+            case QuattrocentoSamplingFrequencyMode.MEDIUM:
+                self._sampling_frequency = 2048
+            case QuattrocentoSamplingFrequencyMode.HIGH:
+                self._sampling_frequency = 5120
+            case QuattrocentoSamplingFrequencyMode.ULTRA:
+                self._sampling_frequency = 10240
+            case _:
+                raise ValueError("Invalid sampling frequency mode.")
+
+    def _set_number_of_channels(self) -> None:
+        mode = self._number_of_channels_mode
+        match mode:
+            case QuattrocentoNumberOfChannelsMode.LOW:
+                self._number_of_channels = 120
+            case QuattrocentoNumberOfChannelsMode.MEDIUM:
+                self._number_of_channels = 216
+            case QuattrocentoNumberOfChannelsMode.HIGH:
+                self._number_of_channels = 312
+            case QuattrocentoNumberOfChannelsMode.ULTRA:
+                self._number_of_channels = 408
+            case _:
+                raise ValueError("Invalid number of channels mode.")
+
+    def get_sampling_frequency(self) -> int:
+        return self._sampling_frequency
+
+    def get_number_of_channels(self) -> int:
+        return self._number_of_channels
+
+    def __int__(self):
+        acq_sett_byte = 1 << 7
+        acq_sett_byte += (self._decimation_mode.value - 1) << 6
+        acq_sett_byte += (self._recording_mode.value - 1) << 5
+        acq_sett_byte += (self._sampling_frequency_mode.value - 1) << 3
+        acq_sett_byte += (self._number_of_channels_mode.value - 1) << 1
+        acq_sett_byte += self._acquisition_mode.value - 1
+
+        return int(acq_sett_byte)
+
+
+# ---------- AN_OUT_IN_SEL BYTE ----------
+# Bit 7 and bit 6 are fixed to 0.
+# TODO:
+
+# ---------- AN_OUT_CH_SEL BYTE ----------
+# Bit 7 and bit 6 are fixed to 0.
+# TODO:
+
+# -- INX_CONF0 and MULTIPLE_INX_CONF0 BYTE --
+# Bit 7 is fixed to 0.
+
+
+class QuattrocentoMuscleSelectionMode(Enum):
+    """
+    Enum class for the muscle selection mode of the
+    Quattrocento device (5 bits).
+    """
+
+
+class QuattrocentoSensorSelectionMode(Enum):
+    """
+    Enum class for the sensor selection mode of the
+    Quattrocento device (5 bits).
+    """
+
+    # TODO: "Implement"
+    ...
+
+
+class QuattrocentoSideMode(Enum):
+    """"""
+
+    _init_ = "value __doc__"
+    UNDEFINED = auto(), "Undefined"
+    LEFT = auto(), "Left"
+    RIGHT = auto(), "Right"
+    NONE = auto(), "None"
+
+
+# ---------- INX_CONF2 BYTE ----------
+
+
+class QuattrocentoHighPassFilterMode(Enum):
+    """
+    Enum class for the high-pass filter of INPUT INX or MULTIPLE INX (2 bits).
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = auto(), "No high-pass filter"
+    LOW = auto(), "High-pass filter at 0.7 Hz"
+    MEDIUM = auto(), "High-pass filter at 10 Hz"
+    HIGH = auto(), "High-pass filter at 100 Hz"
+    ULTRA = auto(), "High-pass filter at 200 Hz"
+
+
+class QuattrocentoLowPassFilterMode(Enum):
+    """
+    Enum class for the low-pass filter of INPUT INX or MULTIPLE INX (2 bits).
+    0 -> LOW: 130 Hz
+    1 -> MEDIUM: 500 Hz
+    2 -> HIGH: 900 Hz
+    3 -> ULTRA: 4400 Hz
+    """
+
+    _init_ = "value __doc__"
+
+    LOW = auto(), "Low-pass filter at 130 Hz"
+    MEDIUM = auto(), "Low-pass filter at 500 Hz"
+    HIGH = auto(), "Low-pass filter at 900 Hz"
+    ULTRA = auto(), "Low-pass filter at 4400 Hz"
+
+
+class QuattrocentoDetectionMode(Enum):
+    """
+    Enum class for the detection mode of the Quattrocento device (2 bits).
+    """
+
+    _init_ = "value __doc_"
+
+    NONE = auto(), "No detection"
+    MONOPOLAR = auto(), "Monopolar detection"
+    BIPOLAR = auto(), "Bipolar detection"
+
+
+class QuattrocentoINXConf2Byte:
+    """
+    Class for the INX_CONF2 byte of the Quattrocento device.
+    """
+
+    def __init__(self):
+        self._muscle_selection_mode: QuattrocentoMuscleSelectionMode = None
+        self._sensor_selection_mode: QuattrocentoSensorSelectionMode = None
+        self._side_mode: QuattrocentoSideMode = QuattrocentoSideMode.UNDEFINED
+        self._high_pass_filter: QuattrocentoHighPassFilterMode = None
+        self._low_pass_filter: QuattrocentoLowPassFilterMode = None
+        self._detection_mode: QuattrocentoDetectionMode = None
+
+    def update(
+        self,
+        high_pass_filter: QuattrocentoHighPassFilterMode,
+        low_pass_filter: QuattrocentoLowPassFilterMode,
+        detection_mode: QuattrocentoDetectionMode,
+    ):
+        self._high_pass_filter = high_pass_filter
+        self._low_pass_filter = low_pass_filter
+        self._detection_mode = detection_mode
+
+    def __int__(self):
+        input_conf_byte_1 = 0  # TODO: Muscle
+        input_conf_byte_2 = 0  # TODO: Sensor + Adapter
+        input_conf_byte_3 = (self._side_mode.value - 1) << 6
+        input_conf_byte_3 += (self._high_pass_filter.value - 1) << 4
+        input_conf_byte_3 += (self._low_pass_filter.value - 1) << 2
+        input_conf_byte_3 += self._detection_mode.value - 1
+
+        return int(
+            (input_conf_byte_1 << 16) + (input_conf_byte_2 << 8) + input_conf_byte_3
+        )
+
 
-QUATTROCENTO_LIGHT_STREAMING_FREQUENCY_DICT: dict[
-    QuattrocentoLightStreamingFrequency, int
-] = {
-    QuattrocentoLightStreamingFrequency.ONE: 1,
-    QuattrocentoLightStreamingFrequency.TWO: 2,
-    QuattrocentoLightStreamingFrequency.FOUR: 4,
-    QuattrocentoLightStreamingFrequency.EIGHT: 8,
-    QuattrocentoLightStreamingFrequency.SIXTEEN: 16,
-    QuattrocentoLightStreamingFrequency.THIRTYTWO: 32,
-}
+QUATTROCENTO_AUXILIARY_CHANNELS: int = 16
+QUATTROCENTO_SUPPLEMENTARY_CHANNELS: int = 8
+QUATTROCENTO_SAMPLES_PER_FRAME: int = 64
+QUATTROCENTO_BYTES_PER_SAMPLE: int = 2

biosignal_device_interface/constants/devices/otb/otb_quattrocento_light_constants.py

@@ -0,0 +1,59 @@
+from aenum import Enum, auto
+
+
+# Quattrocento Light constants
+############# COMMANDS #############
+COMMAND_START_STREAMING = b"startTX"
+COMMAND_STOP_STREAMING = b"stopTX"
+CONNECTION_RESPONSE = b"OTBioLab"
+
+
+############# QUATTROCENTO LIGHT #############
+class QuattrocentoLightSamplingFrequency(Enum):
+    """
+    Enum class for the sampling frequencies of the Quattrocento Light device.
+    """
+
+    _init_ = "value __doc__"
+
+    LOW = auto(), "512 Hz"
+    MEDIUM = auto(), "2048 Hz"
+    HIGH = auto(), "5120 Hz"
+    ULTRA = auto(), "10240 Hz"
+
+
+class QuattrocentoLightStreamingFrequency(Enum):
+    """
+    Enum class for the streaming frequencies of the Quattrocento Light device.
+    """
+
+    _init_ = "value __doc__"
+
+    ONE = auto(), "1 Hz"
+    TWO = auto(), "2 Hz"
+    FOUR = auto(), "4 Hz"
+    EIGHT = auto(), "8 Hz"
+    SIXTEEN = auto(), "16 Hz"
+    THIRTYTWO = auto(), "32 Hz"
+
+
+QUATTROCENTO_SAMPLING_FREQUENCY_DICT: dict[QuattrocentoLightSamplingFrequency, int] = {
+    QuattrocentoLightSamplingFrequency.LOW: 512,
+    QuattrocentoLightSamplingFrequency.MEDIUM: 2048,
+    QuattrocentoLightSamplingFrequency.HIGH: 5120,
+    QuattrocentoLightSamplingFrequency.ULTRA: 10240,
+}
+"""
+Dictionary to get sampling frequency for each mode.
+"""
+
+QUATTROCENTO_LIGHT_STREAMING_FREQUENCY_DICT: dict[
+    QuattrocentoLightStreamingFrequency, int
+] = {
+    QuattrocentoLightStreamingFrequency.ONE: 1,
+    QuattrocentoLightStreamingFrequency.TWO: 2,
+    QuattrocentoLightStreamingFrequency.FOUR: 4,
+    QuattrocentoLightStreamingFrequency.EIGHT: 8,
+    QuattrocentoLightStreamingFrequency.SIXTEEN: 16,
+    QuattrocentoLightStreamingFrequency.THIRTYTWO: 32,
+}

biosignal_device_interface/constants/devices/otb/otb_syncstation_constants.py

@@ -0,0 +1,233 @@
+"""
+Device class for real-time interfacing the OTB Syncstation device.
+Developer: Dominik I. Braun
+Contact: dome.braun@fau.de
+Last Update: 2025-01-09
+"""
+
+from typing import Dict, Union
+from aenum import Enum, auto
+from biosignal_device_interface.constants.devices.core.base_device_constants import (
+    DeviceType,
+    DeviceChannelTypes,
+)
+from biosignal_device_interface.constants.devices.otb.otb_muovi_constants import (
+    MUOVI_AVAILABLE_CHANNELS_DICT,
+)
+
+
+class SyncStationRecOnMode(Enum):
+    """
+    Enum class for the recording on mode of the SyncStation device.
+    """
+
+    _init_ = "value __doc__"
+
+    OFF = auto(), (
+        "The PC is not recording the received signals from SyncStation."
+        "If the Timestapms.log is closed if it was previously opened."
+    )
+    ON = auto(), (
+        "The PC is recording the signals received by the SyncStation."
+        "When triggered, this bit reset the internal timer for the"
+        "ramp counter sent on the Accessory Ch2 and start the log of"
+        "the timestamps on the internal timestamps.log file"
+    )
+
+
+class SyncStationWorkingMode(Enum):
+    """
+    Enum class for the sampling frequency mode of the SyncStation device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No working mode set."
+    EEG = auto(), "EEG Mode Fsamp 500 Hz, DC coupled, 24 bit resolution."
+    EMG = (
+        auto(),
+        "EMG Mode Fsamp 2000 Hz, high pass filter at 10 Hz*, 16 bit resolution",
+    )
+
+
+class SyncStationDetectionMode(Enum):
+    """
+    Enum class for the detection mode of the SyncStation device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No detection mode set."
+    MONOPOLAR_GAIN_HIGH = auto(), (
+        "Monopolar Mode. High gain. 32 monopolar bioelectrical signals + 6 accessory signals. "
+        "Resolution is 286.1 nV and range +/-9.375 mV."
+    )
+    MONOPOLAR_GAIN_LOW = auto(), (
+        "Monopolar Mode. Low gain. 32 monopolar bioelectrical signals + 6 accessory signals. "
+        "Resolution is 572.2nV and range +/-18.75 mV."
+    )
+    IMPEDANCE_CHECK = auto(), "Impedance Check on all 32 + 6 channels."
+    TEST = auto(), "Ramps on all 32 + 6 channels."
+
+
+class SyncStationProbeConfigMode(Enum):
+    """
+    Enum class for the probe configuration mode of the SyncStation device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No probe configuration mode set."
+    MUOVI_PROBE_ONE = auto(), "Probe configuration mode for Muovi probe one."
+    MUOVI_PROBE_TWO = auto(), "Probe configuration mode for Muovi probe two."
+    MUOVI_PROBE_THREE = auto(), "Probe configuration mode for Muovi probe three."
+    MUOVI_PROBE_FOUR = auto(), "Probe configuration mode for Muovi probe four."
+    MUOVI_PLUS_PROBE_ONE = auto(), "Probe configuration mode for Muovi Plus probe one."
+    MUOVI_PLUS_PROBE_TWO = auto(), "Probe configuration mode for Muovi Plus probe two."
+    DUE_PLUS_PROBE_ONE = (
+        auto(),
+        "Probe configuration mode for Due Plus probe one.",
+    )
+    DUE_PLUS_PROBE_TWO = (
+        auto(),
+        "Probe configuration mode for Due Plus probe two.",
+    )
+    DUE_PLUS_PROBE_THREE = (
+        auto(),
+        "Probe configuration mode for Due Plus probe three.",
+    )
+    DUE_PLUS_PROBE_FOUR = (
+        auto(),
+        "Probe configuration mode for Due Plus probe four.",
+    )
+    DUE_PLUS_PROBE_FIVE = (
+        auto(),
+        "Probe configuration mode for Due Plus probe five.",
+    )
+    DUE_PLUS_PROBE_SIX = (
+        auto(),
+        "Probe configuration mode for Due Plus probe six.",
+    )
+    DUE_PLUS_PROBE_SEVEN = (
+        auto(),
+        "Probe configuration mode for Due Plus probe seven.",
+    )
+    DUE_PLUS_PROBE_EIGHT = (
+        auto(),
+        "Probe configuration mode for Due Plus probe eight.",
+    )
+    DUE_PLUS_PROBE_NINE = (
+        auto(),
+        "Probe configuration mode for Due Plus probe nine.",
+    )
+    DUE_PLUS_PROBE_TEN = (
+        auto(),
+        "Probe configuration mode for Due Plus probe ten.",
+    )
+
+
+# DICTS
+
+SYNCSTATION_CHARACTERISTICS_DICT: Dict[str, int] = {
+    DeviceChannelTypes.ALL: 6,
+    "bytes_per_sample": 2,
+    "channel_information": {
+        SyncStationWorkingMode.EEG: {
+            "sampling_frequency": 500,
+            "bytes_per_sample": 3,
+            "frame_size": 5,
+        },
+        SyncStationWorkingMode.EMG: {
+            "sampling_frequency": 2000,
+            "bytes_per_sample": 2,
+            "frame_size": 10,
+        },
+    },
+    "number_of_packages": 32,
+    "package_size": 1460,
+    "FPS": 50,
+}
+
+#  TODO: Load information from Device Constants directly!
+PROBE_CHARACTERISTICS_DICT: Dict[
+    SyncStationProbeConfigMode, Dict[str, Union[str, int]]
+] = {
+    SyncStationProbeConfigMode.MUOVI_PROBE_ONE: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI
+    ],
+    SyncStationProbeConfigMode.MUOVI_PROBE_TWO: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI
+    ],
+    SyncStationProbeConfigMode.MUOVI_PROBE_THREE: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI
+    ],
+    SyncStationProbeConfigMode.MUOVI_PROBE_FOUR: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI
+    ],
+    SyncStationProbeConfigMode.MUOVI_PLUS_PROBE_ONE: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI_PLUS
+    ],
+    SyncStationProbeConfigMode.MUOVI_PLUS_PROBE_TWO: MUOVI_AVAILABLE_CHANNELS_DICT[
+        DeviceType.OTB_MUOVI_PLUS
+    ],
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_ONE: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_TWO: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_THREE: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_FOUR: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_FIVE: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_SIX: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_SEVEN: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_EIGHT: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_NINE: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+    SyncStationProbeConfigMode.DUE_PLUS_PROBE_TEN: {
+        DeviceChannelTypes.ALL: 8,
+        DeviceChannelTypes.BIOSIGNAL: 2,
+        DeviceChannelTypes.AUXILIARY: 6,
+    },
+}
+
+SYNCSTATION_CONVERSION_FACTOR_DICT: dict[SyncStationDetectionMode, int] = {
+    SyncStationDetectionMode.MONOPOLAR_GAIN_HIGH: 572.2e-6,
+    SyncStationDetectionMode.MONOPOLAR_GAIN_LOW: 286.1e-6,
+}
+"""
+Dictionary to get the gain of the Muovi detection mode. \\
+The keys are the detection modes of the Muovi device. \\
+The values are the gain of the detection mode in V.
+"""