py-neuromodulation 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

packages/tmsi/build/lib/TMSiSDK/devices/saga/saga_types.py

@@ -0,0 +1,520 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file ${saga_types.py} 
+ * @brief SAGA Device Types.
+ *
+ */
+
+
+"""
+
+from ...device import (
+    DeviceInterfaceType,
+    DeviceState,
+    DeviceConfig,
+    ChannelType,
+    DeviceChannel,
+    DeviceSensor,
+    ReferenceMethod,
+    ReferenceSwitch,
+)
+
+_TMSI_DEVICE_ID_NONE = 0xFFFF
+
+
+class SagaConst:
+    TMSI_DEVICE_ID_NONE = 0xFFFF
+
+
+class SagaInfo:
+    """'DeviceInfo' holds the static device information. It has the next properties:
+
+    ds_interface : 'DeviceInterfaceType' Indicates interface-type between the PC
+                   and the docking station.
+
+    dr_interface : 'DeviceInterfaceType' Indicates interface-type between the
+                   PC / docking station and the data recorder.
+
+    ds_serial_number : 'int' The serial number of the docking station.
+
+    dr_serial_number : 'int' The serial number of the data recorder.
+
+    """
+
+    def __init__(
+        self,
+        ds_interface=DeviceInterfaceType.none,
+        dr_interface=DeviceInterfaceType.none,
+    ):
+        self.ds_interface = ds_interface
+        self.dr_interface = dr_interface
+        self.id = _TMSI_DEVICE_ID_NONE
+        self.state = DeviceState.disconnected
+
+
+class SagaConfig(DeviceConfig):
+    """'DeviceConfig' holds the actual device configuration"""
+
+    def __init__(self):
+        self._parent = None
+        self._base_sample_rate = 0  # base sample reate in Hz
+        self._configured_interface = DeviceInterfaceType.none
+        self._triggers = 0  # 0= Disabled, 1= external triggers enabled
+        self._reference_method = 0  # 0= Common reference, 1=average reference
+        self._auto_reference_method = 0  #  0= fixed method, 1= autoswitch to average reference when CREF is out of range
+        self._dr_sync_out_divider = (
+            -1
+        )  # SetBaseSampleRateHz/SyncOutDiv, -1 = marker button
+        self._dr_sync_out_duty_cycle = 0  # DR Sync dutycycle
+        self._repair_logging = 0  # 0 = Disabled, 1 = BackupLogging enabled,
+        self._num_channels = 0
+        # Total number of channels : active and inactive
+        self._channels = []  # Total channel list : active and inactive
+        self._sample_rates = []  # List with sample_rate per channel-type
+        self._num_sensors = 0  # Number of sensors
+        self._interface_bandwidth = 0
+        # Data bandwidth in Mbits/s for current interface.
+        for chan_type in ChannelType:
+            self._sample_rates.append(SagaSampleRate(chan_type))
+
+    def get_sample_rate(self, chan_type):
+        """'int' the sample-rate of the specified channel-type-group.
+
+        Args:
+            channel_type : 'ChannelType' The channel-type-group.
+        """
+        return self._sample_rates[chan_type.value].sample_rate
+
+    def set_sample_rate(self, chan_type, bsr_div):
+        """Sets the sample-rate of the specified channel-type-group.
+
+        Args:
+            channel_type : 'ChannelType' The channel-type-group of which the
+            sample-rate must be updated.
+            It is possible to set all channels to the same sample-rate within one
+            call. Then 'ChannelType.all_types' must be used.
+
+            base_sample_rate_divider: 'int' The divider to indicate to what fraction
+            of the active base-sample-rate the sample-rate of the channel-type-group
+            must be set. Only the values 1, 2, 4 and 8 are possible.
+            For example if the base-sample-rate=4000 and base_sample_rate_divider=8,
+            the sample-rate will become 4000/8 = 500 Hz
+
+        Note:
+            Upon a change of the sample-rate of a channel-type-group, automatically
+            the sample-rate of the channels of that channel-type are updated.
+
+            It is advised to "refresh" the applications' local "variables"
+            after the sample-rate of a channel-type-group has been updated.
+        """
+        if (bsr_div == 1) or (bsr_div == 2) or (bsr_div == 4) or (bsr_div == 8):
+            bsr_shift = 0
+            while bsr_div > 1:
+                bsr_shift += 1
+                bsr_div /= 2
+            for ch in self._channels:
+                if (
+                    (ch.type == chan_type)
+                    or (chan_type == ChannelType.all_types)
+                    and (ch.chan_divider != -1)
+                ):
+                    # Only update the chan_divider of active channels
+                    if ch.chan_divider != -1:
+                        ch.chan_divider = bsr_shift
+            if self._parent != None:
+                self._parent._update_config()
+        else:
+            print(
+                "\nProvided base_sample_rate_divider is invalid. Sample rate can not be updated.\n"
+            )
+
+    @property
+    def base_sample_rate(self):
+        """'int' The active base-sample-rate of the device"""
+        return self._base_sample_rate
+
+    @base_sample_rate.setter
+    def base_sample_rate(self, var):
+        """Sets the base-sample-rate of the device.
+
+        Args:
+            sample_rate : 'int' new base sample rate
+
+        Note:
+            Upon a change of the base-sample-rate, automatically the sample-rate
+            of the channel-type-groups (and thus also the sample-rate of every channel)
+            changes.
+
+            It is advised to "refresh" the applications' local "variables"
+            after the base-sample-rate has been updated.
+
+        """
+        if (var == 4000) or (var == 4096):
+            if self._base_sample_rate != var:
+                # The device does not support a configuration with different base
+                # sample rates for sample rate and sync out. Hence sync out config
+                # has to be update as well
+                sync_out_freq = (
+                    self._base_sample_rate / self._dr_sync_out_divider
+                )
+                self._base_sample_rate = var
+                self.set_sync_out_config(freq=sync_out_freq)
+        else:
+            print(
+                "\nProvided base_sample_rate is invalid. Sample rate can not be updated.\n"
+            )
+
+    @property
+    def sample_rate(self):
+        """<int> The rate of the current configuration, with which
+        sample-sets are sent during a measurement. This always
+        equals the sample-rate of the COUNTER-channel.
+        """
+        return self._sample_rates[ChannelType.counter.value].sample_rate
+
+    @property
+    def configured_interface(self):
+        return self._configured_interface
+
+    def set_interface_type(self, dr_interface_type):
+        """Changes the configured interface type of the device.
+
+        Args:
+            dr_interface_type: 'DeviceInterfaceType' The interface type that needs
+            to be updated.
+
+        Note:
+            The interface type switch applies to the DR-DS interface type.
+            Interface types that can be configured on SAGA are docked,
+            optical and wifi.
+        """
+
+        if dr_interface_type.value != self._configured_interface:
+            print("DR-DS interface is changed to: ")
+            print(dr_interface_type)
+            self._configured_interface = dr_interface_type.value
+
+            if self._parent != None:
+                self._parent._update_config()
+
+    @property
+    def num_channels(self):
+        """'int' The total number of channels (enabled and disabled)"""
+        return self._num_channels
+
+    @property
+    def channels(self):
+        """'list DeviceChannel' The total list of channels (enabled and disabled)"""
+        chan_list = []
+        for ch in self._channels:
+            sensor = ch.sensor
+            if ch.sensor != None:
+                sensor = DeviceSensor(
+                    ch.sensor.idx_total_channel_list,
+                    ch.sensor.id,
+                    ch.sensor.serial_nr,
+                    ch.sensor.product_id,
+                    ch.sensor.name,
+                    ch.sensor.unit_name,
+                    ch.sensor.exp,
+                )
+
+            dev_ch = DeviceChannel(
+                ch.type,
+                ch.sample_rate,
+                ch.alt_name,
+                ch.unit_name,
+                (ch.chan_divider != -1),
+                sensor,
+            )
+            chan_list.append(dev_ch)
+        return chan_list
+
+    @channels.setter
+    def channels(self, var):
+        """Updates the channel lists in the device.
+
+        Args:
+            ch_list : 'list DeviceChannel'
+
+            The channel-properties 'enabled' and 'name' can be modified. The other
+            channel-properties are read-only.
+
+        Note:
+            'ch_list' must contain  all channels (enabled and disabled), in the
+            same sequence as retrieved with 'Device.config.channels'
+
+            It is advised to "refresh" the applications' local "variables"
+            after the channel list has been updated.
+        """
+        for idx, channel in enumerate(var):
+            if self._channels[idx].type.value < ChannelType.status.value:
+                self._channels[idx].alt_name = channel.name
+                if channel.enabled == True:
+                    if (
+                        self._sample_rates[
+                            self._channels[idx].type.value
+                        ].sample_rate
+                        != 0
+                    ):
+                        self._channels[idx].sample_rate = self._sample_rates[
+                            self._channels[idx].type.value
+                        ].sample_rate
+                        self._channels[idx].chan_divider = self._sample_rates[
+                            self._channels[idx].type.value
+                        ].chan_divider
+                    else:
+                        self._sample_rates[
+                            self._channels[idx].type.value
+                        ].sample_rate = self._sample_rates[
+                            ChannelType.counter.value
+                        ].sample_rate
+                        self._sample_rates[
+                            self._channels[idx].type.value
+                        ].chan_divider = self._sample_rates[
+                            ChannelType.counter.value
+                        ].chan_divider
+                        self._channels[idx].sample_rate = self._sample_rates[
+                            self._channels[idx].type.value
+                        ].sample_rate
+                        self._channels[idx].chan_divider = self._sample_rates[
+                            self._channels[idx].type.value
+                        ].chan_divider
+                else:
+                    self._channels[idx].chan_divider = -1
+        if self._parent != None:
+            self._parent._update_config()
+
+    @property
+    def reference_method(self):
+        """'ReferenceMethod' the reference method applied to the UNI channels,
+        'ReferenceSwitch' the switching of reference mode when common reference is disconnected"""
+        return (
+            ReferenceMethod(self._reference_method).name,
+            ReferenceSwitch(self._auto_reference_method).name,
+        )
+
+    @reference_method.setter
+    def reference_method(self, reference_type):
+        """Sets the reference method for the UNI channels
+
+        Args:
+            reference_type: 'ReferenceMethod' the type of reference method that
+            should be used for measuring the UNI channels
+            'ReferenceSwitch' the switching of reference mode when common reference is disconnected
+
+        """
+        if not type(reference_type) is tuple:
+            if isinstance(reference_type, ReferenceMethod):
+                self._reference_method = reference_type.value
+            elif isinstance(reference_type, ReferenceSwitch):
+                self._auto_reference_method = reference_type.value
+
+        else:
+            for ind in range(len(reference_type)):
+                if isinstance(reference_type[ind], ReferenceMethod):
+                    self._reference_method = reference_type[ind].value
+                elif isinstance(reference_type[ind], ReferenceSwitch):
+                    self._auto_reference_method = reference_type[ind].value
+
+        if self._parent != None:
+            self._parent._update_config()
+
+    @property
+    def triggers(self):
+        """'Boolean', true when triggers are enabled or false when disabled"""
+        return bool(self._triggers)
+
+    @triggers.setter
+    def triggers(self, enable_triggers):
+        """Sets the triggers to enabled or disabled"""
+        self._triggers = enable_triggers
+        if self._parent != None:
+            self._parent._update_config()
+
+    @property
+    def repair_logging(self):
+        """Boolean, true in case samples are logged on Recorder for repair in case of data loss"""
+        return self._repair_logging
+
+    @repair_logging.setter
+    def repair_logging(self, enable_logging):
+        """Sets repair logging to enabled or disabled"""
+        self._repair_logging = enable_logging
+        if self._parent != None:
+            self._parent._update_config()
+
+    def get_sync_out_config(self):
+        """Sync out configuration, shows whether sync out is in marker mode or square wave mode with corresponding frequency and duty cycle"""
+        if self._dr_sync_out_divider == -1:
+            freq = -1
+        else:
+            freq = self._base_sample_rate / self._dr_sync_out_divider
+        return (
+            self._dr_sync_out_divider == -1,
+            freq,
+            self._dr_sync_out_duty_cycle / 10,
+        )
+
+    def set_sync_out_config(self, marker=False, freq=None, duty_cycle=None):
+        """Set sync out to marker mode or square wave mode with corresponding frequency and duty cycle"""
+        if marker:
+            self._dr_sync_out_divider = -1
+        else:
+            if freq:
+                self._dr_sync_out_divider = round(self._base_sample_rate / freq)
+            if duty_cycle:
+                self._dr_sync_out_duty_cycle = duty_cycle * 10
+
+        if self._parent != None:
+            self._parent._update_config()
+
+    @property
+    def interface_bandwidth(self):
+        return self._interface_bandwidth
+
+    @interface_bandwidth.setter
+    def interface_bandwidth(self, bandwidth):
+        """Sets the data bandwidth in Mbits/s for current interface."""
+        self._interface_bandwidth = bandwidth
+
+
+class SagaSensor:
+    """<SagaSensor> represents the sensor-data of a channel. It has the next properties:
+
+    offset : <float> Offset for the seonsor-channel.
+
+    gain : <float> Value to convert the sensor value to the correct unit value
+
+    exp :  <int> Exponent for the unit, e.g. milli = -3 this gives for a
+            unit_name V a result mV.
+
+    name : <string> The name of the seonsor-channel.
+
+    unit_name : <string> The name of the unit (e.g. 'μVolt)  of the sensor-data.
+
+    """
+
+    def __init__(self):
+        self.idx_total_channel_list = -1
+        self.id = -1
+        self.manufacturer_id = 0
+        self.serial_nr = 0
+        self.product_id = 0
+        self.offset = 0
+        self.gain = 1
+        self.exp = 0
+        self.__name = ""
+        self.__unit_name = ""
+
+    @property
+    def name(self):
+        """'string' The name of the unit (e.g. 'μVolt)  of the sample-data of the channel."""
+        return self.__name
+
+    @name.setter
+    def name(self, bname):
+        self.__name = ""
+        new_name = bytearray()
+        for i in range(len(bname)):
+            if bname[i] > 127:
+                new_name.append(194)  # 0xC2
+            new_name.append(bname[i])
+        if len(new_name) > 0:
+            self.__name = new_name.decode("utf8").rstrip("\x00")
+
+    @property
+    def unit_name(self):
+        """'string' The name of the unit (e.g. 'μVolt)  of the sample-data of the channel."""
+        return self.__unit_name
+
+    @unit_name.setter
+    def unit_name(self, bname):
+        # A unit-name can start with the micro-character (0xB5). In that case must
+        # the micro-character be converted to it;s utf8-representation : 0xC2B5
+        self.__unit_name = ""
+        new_name = bytearray()
+        for i in range(len(bname)):
+            if bname[i] > 127:
+                new_name.append(194)  # 0xC2
+            new_name.append(bname[i])
+        if len(new_name) > 0:
+            self.__unit_name = new_name.decode("utf8").rstrip("\x00")
+
+
+class SagaChannel:
+    """<DeviceChannel> represents a device channel. It has the next properties:
+
+    type : <ChannelType> Indicates the group-type of a channel.
+
+    sample_rate : <int> The curring sampling rate of the channel during a 'normal' measurement.
+
+    name : <string> The name of the channel.
+
+    unit_name : <string> The name of the unit (e.g. 'μVolt)  of the sample-data of the channel.
+
+    enabled : <bool> Indicates if a channel is enavled for measuring
+
+    Note: The properties <name> and <anabled> can be modified. The other properties
+                  are read-only.
+    """
+
+    def __init__(self):
+        self.type = 0
+        self.format = 0
+        self.sample_rate = 0
+        self.chan_divider = -1
+        self.imp_divider = -1
+        self.exp = 1
+        self.__unit_name = "-"
+        self.def_name = "-"
+        self.alt_name = "-"
+        self.sensor = None
+
+    @property
+    def unit_name(self):
+        """'string' The name of the unit (e.g. 'μVolt)  of the sample-data of the channel."""
+        return self.__unit_name
+
+    @unit_name.setter
+    def unit_name(self, name):
+        # A unit-name can start with the micro-character (0xB5). In that case must
+        # the micro-character be converted to it;s utf8-representation : 0xC2B5
+        self.__unit_name = ""
+        bname = name.encode("windows-1252")
+        new_name = bytearray()
+        for i in range(len(bname)):
+            if bname[i] > 127:
+                new_name.append(194)  # 0xC2
+            new_name.append(bname[i])
+        if len(new_name) > 0:
+            self.__unit_name = new_name.decode("utf8")
+
+
+class SagaSampleRate:
+    def __init__(self, type):
+        self.type = type
+        self.sample_rate = 0
+        self.chan_divider = -1

packages/tmsi/build/lib/TMSiSDK/devices/saga/xml_saga_config.py

@@ -0,0 +1,165 @@
+"""
+(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+#######  #     #   #####   #
+   #     ##   ##  #        
+   #     # # # #  #        #
+   #     #  #  #   #####   #
+   #     #     #        #  #
+   #     #     #        #  #
+   #     #     #  #####    #
+
+/**
+ * @file ${xml_saga_config.py} 
+ * @brief Reading/Writing SAGA configuration via XML
+ *
+ */
+
+
+"""
+
+from xml.dom import minidom
+import xml.etree.ElementTree as ET
+
+from .saga_types import SagaConfig, SagaChannel
+
+
+def __prettify(elem):
+    """Return a pretty-printed XML string for the Element."""
+    rough_string = ET.tostring(elem, "utf-8")
+    reparsed = minidom.parseString(rough_string)
+    return reparsed.toprettyxml(indent="  ")
+
+
+def xml_write_config(filename, saga_config):
+    """Writes a device configuration to the specified file.
+
+    Args:
+        'filename' Location of the xml-file to write
+
+        'saga_config' device configuration to write
+
+    Returns:
+        True if successfull, False otherwise.
+    """
+    try:
+        root = ET.Element("DeviceConfig")
+
+        # 1. Write the device configuration properties
+        xml_device = ET.SubElement(root, "Device")
+
+        ET.SubElement(xml_device, "BaseSampleRateHz").text = str(
+            saga_config._base_sample_rate
+        )
+        ET.SubElement(xml_device, "ConfiguredInterface").text = str(
+            saga_config._configured_interface
+        )
+        ET.SubElement(xml_device, "Triggers").text = str(saga_config._triggers)
+        ET.SubElement(xml_device, "ReferenceMethod").text = str(
+            saga_config._reference_method
+        )
+        ET.SubElement(xml_device, "AutoReferenceMethod").text = str(
+            saga_config._auto_reference_method
+        )
+        ET.SubElement(xml_device, "DRSyncOutDiv").text = str(
+            saga_config._dr_sync_out_divider
+        )
+        ET.SubElement(xml_device, "DRSyncOutDutyCycl").text = str(
+            saga_config._dr_sync_out_duty_cycle
+        )
+        ET.SubElement(xml_device, "RepairLogging").text = str(
+            saga_config._repair_logging
+        )
+
+        # 2. Write the channel list
+        xml_channels = ET.SubElement(root, "Channels")
+        for idx, saga_channel in enumerate(saga_config._channels):
+
+            xml_channel = ET.SubElement(xml_channels, "Channel")
+
+            ET.SubElement(xml_channel, "ChanNr").text = str(idx)
+            ET.SubElement(xml_channel, "ChanDivider").text = str(
+                saga_channel.chan_divider
+            )
+            ET.SubElement(
+                xml_channel, "AltChanName"
+            ).text = saga_channel.alt_name
+
+        xml_data = __prettify(root)
+
+        xml_file = open(filename, "w")
+        xml_file.write(xml_data)
+
+        return True
+
+    except:
+        return False
+
+
+def xml_read_config(filename):
+    """Read a device configuration from the specified file.
+
+    Args:
+        'filename' Location of the xml-file to read
+
+    Returns:
+        if successfull :
+            True and a 'SagaConfig'-object with the read configuration.
+        otherwise :
+            False and a default 'SagaConfig'-object
+    """
+    result = True
+    saga_config = SagaConfig()
+
+    try:
+        tree = ET.parse(filename)
+        root = tree.getroot()
+
+        for elem in root:
+            # print(len(elem))
+            for subelem in elem:
+                if elem.tag == "Device":
+                    if subelem.tag == "BaseSampleRateHz":
+                        saga_config._base_sample_rate = int(subelem.text)
+                    if subelem.tag == "ConfiguredInterface":
+                        saga_config._configured_interface = int(subelem.text)
+                    if subelem.tag == "Triggers":
+                        saga_config._triggers = int(subelem.text)
+                    if subelem.tag == "ReferenceMethod":
+                        saga_config._reference_method = int(subelem.text)
+                    if subelem.tag == "AutoReferenceMethod":
+                        saga_config._auto_reference_method = int(subelem.text)
+                    if subelem.tag == "DRSyncOutDiv":
+                        saga_config._dr_sync_out_divider = int(subelem.text)
+                    if subelem.tag == "DRSyncOutDutyCycl":
+                        saga_config._dr_sync_out_duty_cycle = int(subelem.text)
+                    if subelem.tag == "RepairLogging":
+                        saga_config._repair_logging = int(subelem.text)
+                if elem.tag == "Channels":
+                    if subelem.tag == "Channel":
+                        saga_config._num_channels += 1
+                        channel = SagaChannel()
+                        for subsubelem in subelem:
+                            if subsubelem.tag == "ChanDivider":
+                                channel.chan_divider = int(subsubelem.text)
+                            if subsubelem.tag == "AltChanName":
+                                channel.alt_name = subsubelem.text
+
+                        saga_config._channels.append(channel)
+    except:
+        result = False
+        saga_config = None
+
+    return result, saga_config