biosignal-device-interface 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

biosignal_device_interface/constants/devices/core/base_device_constants.py

@@ -21,6 +21,7 @@ class DeviceType(Enum):
     OTB_MUOVI = auto(), "OT Bioelettronica Muovi"
     OTB_MUOVI_PLUS = auto(), "OT Bioelettronica Muovi Plus"
     OTB_SYNCSTATION = auto(), "OT Bioelettronica SyncStation"
+    OTB_SESSANTAQUATTRO = auto(), "OT Bioelettronica Sessantaquattro"
 
 
 class OTBDeviceType(Enum):
@@ -36,6 +37,7 @@ class OTBDeviceType(Enum):
     MUOVI = auto(), "Muovi"
     MUOVI_PLUS = auto(), "Muovi Plus"
     SYNCSTATION = auto(), "SyncStation"
+    SESSANTAQUATTRO = auto(), "Sessantaquattro"
 
 
 class DeviceChannelTypes(Enum):
@@ -58,4 +60,6 @@ DEVICE_NAME_DICT: dict[DeviceType | OTBDeviceType, str] = {
     OTBDeviceType.MUOVI_PLUS: "Muovi Plus",
     DeviceType.OTB_SYNCSTATION: "SyncStation",
     OTBDeviceType.SYNCSTATION: "SyncStation",
+    DeviceType.OTB_SESSANTAQUATTRO: "Sessantaquattro",
+    OTBDeviceType.SESSANTAQUATTRO: "Sessantaquattro",
 }

biosignal_device_interface/constants/devices/otb/otb_sessantaquattro_constants.py

@@ -0,0 +1,227 @@
+"""
+Constants for the Sessantaquattro device.
+
+Developer: Dominik I. Braun
+Contact: dome.braun@fau.de
+Last Update: 2025-09-16
+"""
+
+from typing import Dict
+from aenum import Enum, auto
+
+from biosignal_device_interface.constants.devices.core.base_device_constants import (
+    DeviceChannelTypes,
+)
+
+
+class SessantaquattroSamplingFrequencyMode(Enum):
+    """Enum class for the sampling frequency of the Sessantaquattro device."""
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No sampling frequency set."
+    LOW = auto(), "500 Hz (2000 Hz - Accelerometer)"
+    MEDIUM = auto(), "1000 Hz (4000 Hz - Accelerometer)"
+    HIGH = auto(), "2000 Hz (8000 Hz - Accelerometer)"
+    ULTRA = auto(), "4000 Hz (16000 Hz - Accelerometer)"
+
+
+class SessantaquattroDetectionMode(Enum):
+    """
+    Enum class for the working mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No working mode set."
+    MONOPOLAR = auto(), ("Monopolar Mode")
+    BIPOLAR = auto(), ("Bipolar Mode")
+    DIFFERENTIAL = auto(), ("Differential Mode")
+    ACCELEROMETER = auto(), ("Accelerometer Mode")
+    UNDEFINED = auto(), ("Undefined Mode")
+    IMPEDANCE_ADVANCED = auto(), ("Impedance Check Advanced")
+    IMPEDANCE = auto(), ("Impedance Check")
+    TEST = auto(), ("Test Mode")
+
+
+class SessantaquattroChannelMode(Enum):
+    """
+    Enum class for the channel mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No channel mode set."
+    LOW = auto(), (
+        "8 bioelec. + 2 AUX + 2 accessory (if MODE=001: 4 bio + 2 AUX + 2 acc)"
+    )
+    MEDIUM = auto(), (
+        "16 bioelec. + 2 AUX + 2 accessory (if MODE=001: 8 bio + 2 AUX + 2 acc)"
+    )
+    HIGH = auto(), (
+        "32 bioelec. + 2 AUX + 2 accessory (if MODE=001: 16 bio + 2 AUX + 2 acc)"
+    )
+    ULTRA = auto(), (
+        "64 bioelec. + 2 AUX + 2 accessory (if MODE=001: 32 bio + 2 AUX + 2 acc)"
+    )
+
+
+class SessantaquattroResolutionMode(Enum):
+    """
+    Enum class for the resolution mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No resolution mode set."
+    LOW = auto(), ("16 Bits Resolution")
+    HIGH = auto(), ("24 Bits Resolution")
+
+
+class SessantaquattroGainMode(Enum):
+    """
+    Enum class for the gain mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No gain mode set."
+    DEFAULT = auto(), (
+        "Gain x2 (for 24 bits resolution) / Gain x8 (for 16 bits resolution)"
+    )
+    LOW = auto(), ("Gain x4")
+    MEDIUM = auto(), ("Gain x6")
+    HIGH = auto(), ("Gain x8")
+
+
+class SessantaquattroTriggerMode(Enum):
+    """
+    Enum class for the trigger mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No trigger mode set."
+    DEFAULT = auto(), (
+        "The data transfer is controlled from GO/STOP bit, REC has no effect."
+    )
+    INTERNAL = auto(), (
+        "The data transfer ist triggered by the internal signal (phototransistor)"
+    )
+    EXTERNAL = auto(), (
+        "The data transfer is triggered by the external signal (from the adapter)"
+    )
+    SDCARD = auto(), (
+        "SDCARD: SD card acquisition starts/stops with the hardware button or with the REC bit."
+    )
+
+
+class SessantaquattroRecordingMode(Enum):
+    """
+    Enum class for the recording mode of the Sessantaquattro device.
+    """
+
+    _init_ = "value __doc__"
+
+    NONE = 0, "No recording mode set."
+    STOP = auto(), ("Stop the recording. Works only if TRIG = 3 (SDCARD).")
+    START = auto(), ("Start the recording. Works only if TRIG = 3 (SDCARD).")
+
+
+def _get_sampling_frequency(
+    detection_mode: SessantaquattroDetectionMode,
+    sampling_freq_mode: SessantaquattroSamplingFrequencyMode,
+) -> int:
+    """Get sampling frequency for given detection and sampling frequency modes."""
+    if detection_mode == SessantaquattroDetectionMode.ACCELEROMETER:
+        base_freq = 2000
+    else:
+        base_freq = 500
+
+    multiplier = 2 ** (sampling_freq_mode.value - 1)
+    return base_freq * multiplier
+
+
+def _get_biosignal_channel_count(
+    sampling_freq_mode: SessantaquattroSamplingFrequencyMode,
+    detection_mode: SessantaquattroDetectionMode,
+) -> int:
+    """Get biosignal channel count for given modes."""
+    base_channels = 8 * (2 ** (sampling_freq_mode.value - 1))
+
+    # Bipolar mode has half the channels
+    if detection_mode == SessantaquattroDetectionMode.BIPOLAR:
+        return base_channels // 2
+
+    return base_channels
+
+
+# Generate dictionaries using functions
+SESSANTAQUATTRO_DETECTION_MODE_CHARACTERISTICS_DICT: Dict[
+    SessantaquattroDetectionMode, Dict[SessantaquattroSamplingFrequencyMode, int]
+] = {
+    detection_mode: {
+        sampling_freq: _get_sampling_frequency(detection_mode, sampling_freq)
+        for sampling_freq in SessantaquattroSamplingFrequencyMode
+        if sampling_freq != SessantaquattroSamplingFrequencyMode.NONE
+    }
+    for detection_mode in SessantaquattroDetectionMode
+    if detection_mode != SessantaquattroDetectionMode.NONE
+}
+
+SESSANTAQUATTRO_CHANNEL_MODE_CHARACTERISTICS_DICT: Dict[
+    SessantaquattroSamplingFrequencyMode,
+    Dict[SessantaquattroDetectionMode, Dict[DeviceChannelTypes, int]],
+] = {
+    sampling_freq: {
+        detection_mode: {
+            DeviceChannelTypes.BIOSIGNAL: _get_biosignal_channel_count(
+                sampling_freq, detection_mode
+            ),
+            DeviceChannelTypes.AUXILIARY: 4,
+        }
+        for detection_mode in SessantaquattroDetectionMode
+        if detection_mode != SessantaquattroDetectionMode.NONE
+    }
+    for sampling_freq in SessantaquattroSamplingFrequencyMode
+    if sampling_freq != SessantaquattroSamplingFrequencyMode.NONE
+}
+
+SESSANTAQUATTRO_GAIN_MODE_CHARACTERISTICS_DICT: Dict[
+    SessantaquattroResolutionMode, Dict[SessantaquattroGainMode, float]
+] = {
+    SessantaquattroResolutionMode.LOW: {
+        SessantaquattroGainMode.DEFAULT: 286.1e-6,  # Gain8, 16-bit (in mV, originally 286.1 nV)
+        SessantaquattroGainMode.LOW: 572.2e-6,  # Gain4, 16-bit (in mV, originally 572.2 nV)
+        SessantaquattroGainMode.MEDIUM: 381.5e-6,  # Gain6, 16-bit (in mV, originally 381.5 nV)
+        SessantaquattroGainMode.HIGH: 286.1e-6,  # Gain8, 16-bit (in mV, originally 286.1 nV)
+    },
+    SessantaquattroResolutionMode.HIGH: {
+        SessantaquattroGainMode.DEFAULT: 71.5e-6,  # Gain8, 24-bit (in mV, originally 71.5 nV)
+        SessantaquattroGainMode.LOW: 143.0e-6,  # Gain4, 24-bit (in mV, originally 143.0 nV)
+        SessantaquattroGainMode.MEDIUM: 95.4e-6,  # Gain6, 24-bit (in mV, originally 95.4 nV)
+        SessantaquattroGainMode.HIGH: 71.5e-6,  # Gain8, 24-bit (in mV, originally 71.5 nV)
+    },
+}
+
+SESSANTAQUATTRO_AUXILIARY_LSB_DICT: Dict[SessantaquattroResolutionMode, float] = {
+    SessantaquattroResolutionMode.LOW: 146.48e-6,  # in mV (originally 146.48 nV)
+    SessantaquattroResolutionMode.HIGH: 572.2e-6,  # in mV (originally 572.2 nV)
+}
+
+SESSANTAQUATTRO_SAMPLES_PER_FRAME_DICT: Dict[SessantaquattroChannelMode, int] = {
+    SessantaquattroChannelMode.LOW: 48,
+    SessantaquattroChannelMode.MEDIUM: 28,
+    SessantaquattroChannelMode.HIGH: 16,
+    SessantaquattroChannelMode.ULTRA: 8,
+}
+
+if __name__ == "__main__":
+    # Print the generated dictionaries for verification
+    import pprint
+
+    print("Sessantaquattro Detection Mode Characteristics Dictionary:")
+    pprint.pprint(SESSANTAQUATTRO_DETECTION_MODE_CHARACTERISTICS_DICT)
+
+    print("\nSessantaquattro Channel Mode Characteristics Dictionary:")
+    pprint.pprint(SESSANTAQUATTRO_CHANNEL_MODE_CHARACTERISTICS_DICT)

biosignal_device_interface/devices/__init__.py

@@ -5,9 +5,11 @@ from biosignal_device_interface.devices.otb import (
     OTBMuoviWidget,
     OTBMuoviPlusWidget,
     OTBQuattrocentoLightWidget,
+    OTBSessantaquattroWidget,
     OTBMuovi,
     OTBQuattrocento,
     OTBQuattrocentoLight,
+    OTBSessantaquattro,
     OTBSyncStationWidget,
     OTBDevicesWidget,
 )

biosignal_device_interface/devices/otb/__init__.py

@@ -4,6 +4,9 @@ from biosignal_device_interface.devices.otb.otb_quattrocento_light import (
 )
 from biosignal_device_interface.devices.otb.otb_muovi import OTBMuovi
 from biosignal_device_interface.devices.otb.otb_syncstation import OTBSyncStation
+from biosignal_device_interface.devices.otb.otb_sessantaquattro import (
+    OTBSessantaquattro,
+)
 
 # Widgets
 # All OTB Devices Widget
@@ -27,3 +30,6 @@ from biosignal_device_interface.gui.device_template_widgets.otb.otb_quattrocento
 from biosignal_device_interface.gui.device_template_widgets.otb.otb_syncstation_widget import (
     OTBSyncStationWidget,
 )
+from biosignal_device_interface.gui.device_template_widgets.otb.otb_sessantaquattro_widget import (
+    OTBSessantaquattroWidget,
+)

biosignal_device_interface/devices/otb/otb_muovi.py

@@ -212,6 +212,7 @@ class OTBMuovi(BaseDevice):
     def clear_socket(self) -> None:
         if self._client_socket is not None:
             self._client_socket.readAll()
+            self._received_bytes = bytearray()
 
     def _read_data(self) -> None:
         super()._read_data()

biosignal_device_interface/devices/otb/otb_quattrocento.py

@@ -57,7 +57,7 @@ class OTBQuattrocento(BaseDevice):
 
         # Device Information
         self._conversion_factor_biosignal: float = 5 / (2**16) / 150 * 1000  # in mV
-        self._conversion_factor_auxiliary: float = 5 / (2**16) / 0.5  # in mV
+        self._conversion_factor_auxiliary: float = 5 / (2**16) / 0.5  # in V
         self._number_of_streamed_channels: int = None
 
         # Connection Parameters

biosignal_device_interface/devices/otb/otb_quattrocento_light.py

@@ -60,7 +60,7 @@ class OTBQuattrocentoLight(BaseDevice):
         self._auxiliary_channel_start_index: int = 384  # Fix value
         self._number_of_auxiliary_channels: int = 16  # Fix value
         self._conversion_factor_biosignal: float = 5 / (2**16) / 150 * 1000  # in mV
-        self._conversion_factor_auxiliary: float = 5 / (2**16) / 0.5  # in mV
+        self._conversion_factor_auxiliary: float = 5 / (2**16) / 0.5  # in V
         self._bytes_per_sample: int = 2  # Fix value
         # Quattrocento unique parameters
         self._streaming_frequency: int | None = None

biosignal_device_interface/devices/otb/otb_sessantaquattro.py

@@ -0,0 +1,363 @@
+"""
+Device class for real-time interfacing the Sessantaquattro device.
+Developer: Dominik I. Braun
+Contact: dome.braun@fau.de
+Last Update: 2025-09-16
+"""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING, Union, Dict
+from PySide6.QtNetwork import QTcpSocket, QTcpServer, QHostAddress
+import numpy as np
+
+# Local Libraries
+from biosignal_device_interface.devices.core.base_device import BaseDevice
+from biosignal_device_interface.constants.devices.core.base_device_constants import (
+    DeviceType,
+    DeviceChannelTypes,
+)
+
+# Constants
+from biosignal_device_interface.constants.devices.otb.otb_sessantaquattro_constants import (
+    SESSANTAQUATTRO_AUXILIARY_LSB_DICT,
+    SESSANTAQUATTRO_CHANNEL_MODE_CHARACTERISTICS_DICT,
+    SESSANTAQUATTRO_DETECTION_MODE_CHARACTERISTICS_DICT,
+    SESSANTAQUATTRO_GAIN_MODE_CHARACTERISTICS_DICT,
+    SESSANTAQUATTRO_SAMPLES_PER_FRAME_DICT,
+    SessantaquattroChannelMode,
+    SessantaquattroDetectionMode,
+    SessantaquattroGainMode,
+    SessantaquattroRecordingMode,
+    SessantaquattroResolutionMode,
+    SessantaquattroSamplingFrequencyMode,
+    SessantaquattroTriggerMode,
+)
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QMainWindow, QWidget
+    from aenum import Enum
+
+
+class OTBSessantaquattro(BaseDevice):
+    """
+    Device class for real-time interfacing the Sessantaquattro device.
+
+    parent (Union[QMainWindow, QWidget], optional):
+            Parent widget to which the device is assigned to.
+            Defaults to None.
+
+    The Sessantaquattro class is using a TCP/IP protocol to communicate with the device.
+    """
+
+    def __init__(
+        self,
+        parent: Union[QMainWindow, QWidget],
+    ) -> None:
+        """Initialize the OTBSessantaquattro device.
+
+        Args:
+            parent (Union[QMainWindow, QWidget]): Parent widget to which the device is assigned to.
+        """
+        super().__init__(parent=parent)
+
+        # Device Parameters
+        self._device_type: DeviceType = DeviceType.OTB_SESSANTAQUATTRO
+
+        # Connection Parameters
+        self._interface: QTcpServer = None
+        self._client_socket: QTcpSocket = None
+
+        # Configuration Parameters
+        ## Control Byte 0
+        self._sampling_frequency_mode: SessantaquattroSamplingFrequencyMode = (
+            SessantaquattroSamplingFrequencyMode.NONE
+        )
+        self._channel_mode: SessantaquattroChannelMode = SessantaquattroChannelMode.NONE
+        self._detection_mode: SessantaquattroDetectionMode = (
+            SessantaquattroDetectionMode.NONE
+        )
+
+        ## Control  Byte 1
+        self._resolution_mode: SessantaquattroResolutionMode = (
+            SessantaquattroResolutionMode.NONE
+        )
+        self._gain_mode: SessantaquattroGainMode = SessantaquattroGainMode.NONE
+        self._trigger_mode: SessantaquattroTriggerMode = SessantaquattroTriggerMode.NONE
+        self._recording_mode: SessantaquattroRecordingMode = (
+            SessantaquattroRecordingMode.NONE
+        )
+
+    def _connect_to_device(self):
+        super()._connect_to_device()
+
+        self._interface = QTcpServer(self)
+        self._received_bytes: bytearray = bytearray()
+
+        if not self._interface.listen(
+            QHostAddress(self._connection_settings[0]), self._connection_settings[1]
+        ):
+            return False
+
+        self._interface.newConnection.connect(self._make_request)
+
+        self._connection_timeout_timer.start()
+
+        return True
+
+    def _make_request(self) -> bool:
+        super()._make_request()
+        self._client_socket = self._interface.nextPendingConnection()
+
+        if self._client_socket:
+
+            self._client_socket.readyRead.connect(self._read_data)
+
+            if not self.is_connected:
+                self.is_connected = True
+                self.connect_toggled.emit(self.is_connected)
+                self._connection_timeout_timer.stop()
+                return True
+
+            elif not self._is_configured:
+                self._is_configured = True
+                self.configure_toggled.emit(self._is_configured)
+                return True
+
+    def _disconnect_from_device(self) -> bool:
+        super()._disconnect_from_device()
+
+        if self._client_socket is not None:
+            self._client_socket.readyRead.disconnect(self._read_data)
+            self._client_socket.disconnectFromHost()
+            self._client_socket.close()
+
+        if self._interface is not None:
+            self._interface.close()
+
+        return True
+
+    def configure_device(
+        self, params: Dict[str, Union[Enum, Dict[str, Enum]]]  # type: ignore
+    ) -> None:
+        super().configure_device(params)
+
+        if not self.is_connected or self._client_socket is None:
+            return
+
+        # Set Configuration Parameters
+        self._sampling_frequency = SESSANTAQUATTRO_DETECTION_MODE_CHARACTERISTICS_DICT[
+            self._detection_mode
+        ][self._sampling_frequency_mode]
+
+        channels = SESSANTAQUATTRO_CHANNEL_MODE_CHARACTERISTICS_DICT[
+            self._sampling_frequency_mode
+        ][self._detection_mode]
+
+        self._number_of_biosignal_channels = channels[DeviceChannelTypes.BIOSIGNAL]
+        self._biosignal_channel_indices = np.arange(
+            0, self._number_of_biosignal_channels
+        )
+        self._number_of_auxiliary_channels = channels[DeviceChannelTypes.AUXILIARY]
+        self._auxiliary_channel_indices = np.arange(
+            self._number_of_biosignal_channels,
+            self._number_of_biosignal_channels + self._number_of_auxiliary_channels,
+        )
+
+        self._number_of_channels = (
+            self._number_of_biosignal_channels + self._number_of_auxiliary_channels
+        )
+
+        self._bytes_per_sample = (
+            2 if self._resolution_mode == SessantaquattroResolutionMode.LOW else 3
+        )
+
+        self._conversion_factor_biosignal = SESSANTAQUATTRO_GAIN_MODE_CHARACTERISTICS_DICT[
+            self._resolution_mode
+        ][self._gain_mode]
+
+        self._conversion_factor_auxiliary = SESSANTAQUATTRO_AUXILIARY_LSB_DICT[
+            self._resolution_mode
+        ]
+
+        self._samples_per_frame = SESSANTAQUATTRO_SAMPLES_PER_FRAME_DICT[
+            self._channel_mode
+        ]
+
+        # Prepare streaming
+        self._buffer_size = (
+            self._number_of_channels * self._samples_per_frame * self._bytes_per_sample
+        )
+
+        self._received_bytes = bytearray()
+
+        self._configure_command()
+        self._send_configuration_to_device()
+
+    def _send_configuration_to_device(self) -> None:
+        configuration_bytes = int(self._configuration_command).to_bytes(
+            2, byteorder="big"
+        )
+
+        success = self._client_socket.write(configuration_bytes)
+
+        if success == -1:
+            self._disconnect_from_device()
+
+    def _configure_command(self) -> None:
+        self._configuration_command = 0
+
+        # Control Byte 0
+        # Bit 0 - Transmission Mode | Handled by Start / Stop Streaming
+        # Bit 1
+        if self._recording_mode is None or self._recording_mode == SessantaquattroRecordingMode.NONE:
+            self._recording_mode = SessantaquattroRecordingMode.STOP
+        self._configuration_command += (self._recording_mode.value - 1) << 1
+
+        # Bit 3-2
+        if self._trigger_mode is None or self._trigger_mode == SessantaquattroTriggerMode.NONE:
+            self._trigger_mode = SessantaquattroTriggerMode.DEFAULT
+        self._configuration_command += (self._trigger_mode.value - 1) << 2
+
+        # Bit 5-4
+        if self._gain_mode is None or self._gain_mode == SessantaquattroGainMode.NONE:
+            self._gain_mode = SessantaquattroGainMode.DEFAULT
+        self._configuration_command += (self._gain_mode.value - 1) << 4
+
+        # Bit 6 - Filter mode: enable high pass filter
+        self._configuration_command += 1 << 6
+
+        # Bit 7 - Resolution mode
+        if self._resolution_mode is None or self._resolution_mode == SessantaquattroResolutionMode.NONE:
+            self._resolution_mode = SessantaquattroResolutionMode.LOW
+        self._configuration_command += (self._resolution_mode.value - 1) << 7
+
+        # Control Byte 1
+        # Bit 2-0 - Detection Mode
+        if self._detection_mode is None or self._detection_mode == SessantaquattroDetectionMode.NONE:
+            self._detection_mode = SessantaquattroDetectionMode.MONOPOLAR
+        self._configuration_command += (self._detection_mode.value - 1) << 8
+
+        # Bit 4-3 - Channel Mode
+        if self._channel_mode is None or self._channel_mode == SessantaquattroChannelMode.NONE:
+            self._channel_mode = SessantaquattroChannelMode.LOW
+        self._configuration_command += (self._channel_mode.value - 1) << 11
+
+        # Bit 6-5 - Sampling Frequency Mode
+        if self._sampling_frequency_mode is None or self._sampling_frequency_mode == SessantaquattroSamplingFrequencyMode.NONE:
+            self._sampling_frequency_mode = SessantaquattroSamplingFrequencyMode.HIGH
+        self._configuration_command += (self._sampling_frequency_mode.value - 1) << 13
+
+        # Bit 7 - GETSET - always 0 for setting the configuration
+        self._configuration_command += 0 << 15
+
+    def _start_streaming(self) -> None:
+        super()._start_streaming()
+
+        if self._configuration_command is None:
+            return
+
+        self._configuration_command += 1
+        self._send_configuration_to_device()
+
+    def _stop_streaming(self) -> None:
+        super()._stop_streaming()
+
+        if self._configuration_command is None:
+            return
+
+        self._configuration_command -= 1
+        self._send_configuration_to_device()
+
+    def clear_socket(self) -> None:
+        if self._client_socket is not None:
+            self._client_socket.readAll()
+            self._received_bytes = bytearray()
+
+    def _read_data(self) -> None:
+        super()._read_data()
+
+        if self._client_socket is None:
+            return
+
+        if not self._is_streaming:
+            buffer_size: int = 13
+            config_bytes = self._client_socket.read(
+                buffer_size
+            )  # TODO: Catches configuration settings, has to be checked
+
+            self._process_configuration_data(config_bytes)
+            return
+
+        while self._client_socket.bytesAvailable() > self._buffer_size:
+            packet = self._client_socket.read(self._buffer_size)
+            if not packet:
+                continue
+
+            self._received_bytes.extend(packet)
+
+            while len(self._received_bytes) >= self._buffer_size:
+                data_to_process = self._received_bytes[: self._buffer_size]
+                self._process_data(data_to_process)
+                self._received_bytes = self._received_bytes[self._buffer_size :]
+
+    def _process_configuration_data(self, input: bytearray) -> None:
+        # TODO: Implement configuration data processing
+        ...
+
+    def _process_data(self, input: bytearray) -> None:
+        super()._process_data(input)
+
+        decoded_data = self._bytes_to_integers(input)
+
+        processed_data = decoded_data.reshape(
+            self._number_of_channels, -1, order="F"
+        ).astype(np.float32)
+
+        self.data_available.emit(processed_data)
+        self.biosignal_data_available.emit(self._extract_biosignal_data(processed_data))
+        self.auxiliary_data_available.emit(self._extract_auxiliary_data(processed_data))
+
+    # Convert integer to bytes
+    def _integer_to_bytes(self, command: int) -> bytes:
+        return command.to_bytes(2, byteorder="big")
+
+    # Convert channels from bytes to integers
+    def _bytes_to_integers(
+        self,
+        data: bytearray,
+    ) -> np.ndarray:
+        channel_values = []
+        # Separate channels from byte-string. One channel has
+        # "bytes_in_sample" many bytes in it.
+        for channel_index in range(len(data) // 2):
+            channel_start = channel_index * self._bytes_per_sample
+            channel_end = (channel_index + 1) * self._bytes_per_sample
+            channel = data[channel_start:channel_end]
+
+            # Convert channel's byte value to integer
+            if self._resolution_mode == SessantaquattroResolutionMode.LOW:
+                value = self._decode_int16(channel)
+            else:
+                value = self._decode_int24(channel)
+            channel_values.append(value)
+
+        return np.array(channel_values)
+
+    def _decode_int16(self, bytes_value: bytearray) -> int:
+        value = None
+        # Combine 2 bytes to a 16 bit integer value
+        value = bytes_value[0] * 256 + bytes_value[1]
+        # See if the value is negative and make the two's complement
+        if value >= 32768:
+            value -= 65536
+        return value
+
+    # Convert byte-array value to an integer value and apply two's complement
+    def _decode_int24(self, bytes_value: bytearray) -> int:
+        value = None
+        # Combine 3 bytes to a 24 bit integer value
+        value = bytes_value[0] * 65536 + bytes_value[1] * 256 + bytes_value[2]
+        # See if the value is negative and make the two's complement
+        if value >= 8388608:
+            value -= 16777216
+        return value

biosignal_device_interface/gui/device_template_widgets/all_devices_widget.py

@@ -29,6 +29,9 @@ from biosignal_device_interface.gui.device_template_widgets.otb.otb_quattrocento
 from biosignal_device_interface.gui.device_template_widgets.otb.otb_syncstation_widget import (
     OTBSyncStationWidget,
 )
+from biosignal_device_interface.gui.device_template_widgets.otb.otb_sessantaquattro_widget import (
+    OTBSessantaquattroWidget,
+)
 
 if TYPE_CHECKING:
     from PySide6.QtWidgets import QWidget, QMainWindow
@@ -47,5 +50,6 @@ class AllDevicesWidget(BaseMultipleDevicesWidget):
             DeviceType.OTB_MUOVI: OTBMuoviWidget(self),
             DeviceType.OTB_MUOVI_PLUS: OTBMuoviPlusWidget(self),
             DeviceType.OTB_SYNCSTATION: OTBSyncStationWidget(self),
+            DeviceType.OTB_SESSANTAQUATTRO: OTBSessantaquattroWidget(self),
         }
         self._set_devices(self._device_selection)