biosignal-device-interface 0.1.311__py3-none-any.whl → 0.2.1a1__py3-none-any.whl

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

@@ -0,0 +1,313 @@
+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.
+    """
+
+    _init_ = "value __doc__"
+
+    STOP = auto(), "Stop"
+    START = auto(), "Start"
+
+
+class QuattrocentoSamplingFrequencyMode(Enum):
+    """
+    Enum class for the sampling frequencies of the Quattrocento device (2 bits).
+    """
+
+    _init_ = "value __doc__"
+
+    LOW = auto(), "512 Hz"
+    MEDIUM = auto(), "2048 Hz"
+    HIGH = auto(), "5120 Hz"
+    ULTRA = auto(), "10240 Hz"
+
+
+class QuattrocentoNumberOfChannelsMode(Enum):
+    """
+    Enum class for the number of channels of the Quattrocento device (2 bits).
+    """
+
+    _init_ = "value __doc__"
+
+    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."
+
+
+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_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_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.
+"""

biosignal_device_interface/devices/__init__.py

@@ -6,7 +6,9 @@ from biosignal_device_interface.devices.otb import (
     OTBMuoviPlusWidget,
     OTBQuattrocentoLightWidget,
     OTBMuovi,
+    OTBQuattrocento,
     OTBQuattrocentoLight,
+    OTBSyncStationWidget,
     OTBDevicesWidget,
 )
 

biosignal_device_interface/devices/core/base_device.py

@@ -73,7 +73,7 @@ class BaseDevice(QObject):
         self._connection_timeout_timer.setInterval(1000)
 
         # Device Status
-        self._is_connected: bool = False
+        self.is_connected: bool = False
         self._is_configured: bool = False
         self._is_streaming: bool = False
 
@@ -114,7 +114,7 @@ class BaseDevice(QObject):
             bool:
                 Success of the disconnection attempt.
         """
-        self._is_connected = False
+        self.is_connected = False
         self.connect_toggled.emit(False)
         self._is_configured = False
         self.configure_toggled.emit(False)
@@ -299,7 +299,7 @@ class BaseDevice(QObject):
         """
         self._connection_settings = settings
 
-        if self._is_connected:
+        if self.is_connected:
             if self._is_streaming:
                 self.toggle_streaming()
 
@@ -395,6 +395,8 @@ class BaseDevice(QObject):
                     or "wifi" in interface.lower()
                     or "wireless" in interface.lower()
                     or "en0" in interface.lower()
+                    or "wlp" in interface.lower()
+                    or "wln" in interface.lower()
                 ):
                     for address in addresses:
                         # Check if the address is an IPv4 address and not a loopback or virtual address

biosignal_device_interface/devices/otb/__init__.py

@@ -1,7 +1,9 @@
+from biosignal_device_interface.devices.otb.otb_quattrocento import OTBQuattrocento
 from biosignal_device_interface.devices.otb.otb_quattrocento_light import (
     OTBQuattrocentoLight,
 )
 from biosignal_device_interface.devices.otb.otb_muovi import OTBMuovi
+from biosignal_device_interface.devices.otb.otb_syncstation import OTBSyncStation
 
 # Widgets
 # All OTB Devices Widget
@@ -16,6 +18,12 @@ from biosignal_device_interface.gui.device_template_widgets.otb.otb_muovi_widget
 from biosignal_device_interface.gui.device_template_widgets.otb.otb_muovi_plus_widget import (
     OTBMuoviPlusWidget,
 )
+from biosignal_device_interface.gui.device_template_widgets.otb.otb_quattrocento_widget import (
+    OTBQuattrocentoWidget,
+)
 from biosignal_device_interface.gui.device_template_widgets.otb.otb_quattrocento_light_widget import (
     OTBQuattrocentoLightWidget,
 )
+from biosignal_device_interface.gui.device_template_widgets.otb.otb_syncstation_widget import (
+    OTBSyncStationWidget,
+)

biosignal_device_interface/devices/otb/otb_muovi.py

@@ -1,4 +1,3 @@
-# Python Libraries
 """
 Device class for real-time interfacing the Muovi device.
 Developer: Dominik I. Braun
@@ -101,9 +100,9 @@ class OTBMuovi(BaseDevice):
 
             self._client_socket.readyRead.connect(self._read_data)
 
-            if not self._is_connected:
-                self._is_connected = True
-                self.connect_toggled.emit(self._is_connected)
+            if not self.is_connected:
+                self.is_connected = True
+                self.connect_toggled.emit(self.is_connected)
                 self._connection_timeout_timer.stop()
                 return True
 
@@ -130,7 +129,7 @@ class OTBMuovi(BaseDevice):
     ) -> None:
         super().configure_device(params)
 
-        if not self._is_connected or self._client_socket is None:
+        if not self.is_connected or self._client_socket is None:
             return
 
         # Check if detection mode is valid for working mode (Case EEG -> MONOPOLAR_GAIN_4 => MONOPOLAR_GAIN_8)