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

packages/tmsi/build/lib/apex_sdk/device/devices/apex/measurements/eeg_measurement.py

@@ -0,0 +1,150 @@
+"""
+(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 eeg_measurement.py 
+ * @brief 
+ * Class to handle the communication with the device for  EEG acquisition.
+ */
+
+
+"""
+
+from copy import deepcopy
+from ctypes import *
+import time
+
+from .....tmsi_utilities.tmsi_logger import TMSiLogger as logger
+from .....sample_data_server.sample_data_server import SampleDataServer
+from .....sample_data_server.sample_data import SampleData
+from .....tmsi_utilities import support_functions
+from .....tmsi_utilities.decorators import LogPerformances
+from ..apex_API_structures import TMSiDevSampleRequest
+from ..apex_API_enums import SampleControl, TMSiDeviceRetVal
+from ....tmsi_measurement import TMSiMeasurement
+
+
+class EEGMeasurement(TMSiMeasurement):
+    def __init__(self, dev, name="EEG Measurement"):
+        super().__init__(dev=dev, name=name)
+        self._sample_data_buffer = (c_float * self._sample_data_buffer_size)(0)
+        self._num_samples_per_set = dev.get_num_channels()
+        self._converter = {}
+        channels = self._dev.get_device_channels()
+        for i in range(self._num_samples_per_set):
+            conversion_factor = 10 ** channels[i].get_channel_exp()
+            if conversion_factor in self._converter:
+                self._converter[conversion_factor].append(i)
+            else:
+                self._converter[conversion_factor] = [i]
+
+    @LogPerformances
+    def start(self):
+        self._dev.reset_device_data_buffer()
+        measurement_request = TMSiDevSampleRequest()
+        measurement_request.DisableLiveImp = self._disable_live_impedance
+        measurement_request.DisableAvrRefCalc = (
+            self._disable_average_reference_calculation
+        )
+        measurement_request.StartStop = SampleControl.StartSampling.value
+        self._dev.set_device_sampling_request(measurement_request)
+        self._sampling_thread.start()
+        self._conversion_thread.start()
+
+    @LogPerformances
+    def stop(self):
+        measurement_request = TMSiDevSampleRequest()
+        measurement_request.DisableLiveImp = self._disable_live_impedance
+        measurement_request.DisableAvrRefCalc = (
+            self._disable_average_reference_calculation
+        )
+        measurement_request.StartStop = SampleControl.StopSampling.value
+        self._dev.set_device_sampling_request(measurement_request)
+        self._sampling_thread.stop()
+        self._conversion_thread.stop()
+
+    @LogPerformances
+    def _conversion_function(self):
+        while not self._conversion_queue.empty():
+            (
+                sample_data_buffer,
+                retrieved_sample_sets,
+            ) = self._conversion_queue.get()
+            if retrieved_sample_sets > 0:
+                sample_mat = support_functions.array_to_matrix(
+                    sample_data_buffer[
+                        : self._num_samples_per_set * retrieved_sample_sets
+                    ],
+                    self._num_samples_per_set,
+                )
+                for i in self._float_channels:
+                    sample_mat[i] = support_functions.float_to_uint(
+                        sample_mat[i]
+                    )
+                for factor in self._converter.keys():
+                    for channel in self._converter[factor]:
+                        sample_mat[channel] = [
+                            i / factor for i in sample_mat[channel]
+                        ]
+                samples = support_functions.matrix_to_multiplexed_array(
+                    sample_mat
+                )
+                samples = [
+                    0.0 if i == 4294967296000000.0 else i for i in samples
+                ]
+                sd = SampleData(
+                    retrieved_sample_sets, self._num_samples_per_set, samples
+                )
+                logger().debug(
+                    "Data delivered to sample data server: {} channels, {} samples".format(
+                        self._num_samples_per_set, retrieved_sample_sets
+                    )
+                )
+                SampleDataServer().put_sample_data(self._dev.get_id(), sd)
+
+    @LogPerformances
+    def _sampling_function(self):
+        ret = self._dev.get_device_data(
+            pointer(self._sample_data_buffer),
+            self._sample_data_buffer_size,
+            pointer(self._retrieved_sample_sets),
+            pointer(self._retrieved_data_type),
+        )
+        if ret == TMSiDeviceRetVal.TMSiStatusOK:
+            if self._retrieved_sample_sets.value > 0:
+                self._conversion_queue.put(
+                    (
+                        deepcopy(self._sample_data_buffer),
+                        self._retrieved_sample_sets.value,
+                    )
+                )
+                self._tic_timeout = time.perf_counter()
+                self._empty_read_counter = 0
+            else:
+                if self._empty_read_counter == 0:
+                    self._empty_read_counter = 1
+        if self._download_samples_limit is not None:
+            self._downloaded_samples += self._retrieved_sample_sets.value
+            self._download_percentage = (
+                self._downloaded_samples * 100.0 / self._download_samples_limit
+            )

packages/tmsi/build/lib/apex_sdk/device/devices/apex/measurements/impedance_measurement.py

@@ -0,0 +1,129 @@
+"""
+(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 impedance_measurement.py 
+ * @brief 
+ * Class to handle the communication with the device for  impedance acquisition.
+ */
+
+
+"""
+
+from copy import deepcopy
+from ctypes import *
+import time
+
+from .....tmsi_utilities.tmsi_logger import TMSiLogger as logger
+from .....sample_data_server.sample_data_server import SampleDataServer
+from .....sample_data_server.sample_data import SampleData
+from .....tmsi_utilities.decorators import LogPerformances
+from ..apex_API_structures import TMSiImpedanceSample, TMSiDevImpedanceRequest
+from ..apex_API_enums import ImpedanceControl, TMSiDeviceRetVal
+from ....tmsi_measurement import TMSiMeasurement
+
+
+class ImpedanceMeasurement(TMSiMeasurement):
+    def __init__(self, dev, name="Impedance Measurement"):
+        super().__init__(dev=dev, name=name)
+        self._sample_data_buffer = (
+            TMSiImpedanceSample * self._sample_data_buffer_size
+        )(TMSiImpedanceSample())
+        self._num_samples_per_set = dev.get_num_impedance_channels()
+
+    @LogPerformances
+    def _sampling_function(self):
+        ret = self._dev.get_device_impedance_data(
+            pointer(self._sample_data_buffer),
+            self._sample_data_buffer_size,
+            pointer(self._retrieved_sample_sets),
+        )
+        if ret == TMSiDeviceRetVal.TMSiStatusOK:
+            if self._retrieved_sample_sets.value > 0:
+                self._conversion_queue.put(
+                    (
+                        deepcopy(self._sample_data_buffer),
+                        self._retrieved_sample_sets.value,
+                    )
+                )
+                self._empty_read_counter = 0
+            else:
+                if self._empty_read_counter == 0:
+                    self._tic_timeout = time.perf_counter()
+                self._empty_read_counter += 1
+
+    @LogPerformances
+    def _conversion_function(self):
+        while not self._conversion_queue.empty():
+            (
+                sample_data_buffer,
+                retrieved_sample_sets,
+            ) = self._conversion_queue.get()
+            if retrieved_sample_sets > 0:
+                sample_mat = [
+                    sample_data_buffer[
+                        ii : retrieved_sample_sets
+                        * self._num_samples_per_set : self._num_samples_per_set
+                    ]
+                    for ii in range(self._num_samples_per_set)
+                ]
+                samples_exploded = [
+                    [
+                        i.ImpedanceRe if ii % 2 == 0 else i.ImpedanceIm
+                        for i in sample_mat[ii // 2]
+                    ]
+                    for ii in range(self._num_samples_per_set * 2)
+                ]
+                samples_exploded_inline = [
+                    samples_exploded[i][j]
+                    for j in range(len(samples_exploded[0]))
+                    for i in range(len(samples_exploded))
+                ]
+                sd = SampleData(
+                    retrieved_sample_sets,
+                    self._num_samples_per_set * 2,
+                    samples_exploded_inline,
+                )
+                logger().debug(
+                    "Data delivered to sample data server: {} channels, {} samples".format(
+                        self._num_samples_per_set, retrieved_sample_sets
+                    )
+                )
+                SampleDataServer().put_sample_data(self._dev.get_id(), sd)
+
+    @LogPerformances
+    def start(self):
+        self._dev.reset_device_data_buffer()
+        measurement_request = TMSiDevImpedanceRequest()
+        measurement_request.StartStop = ImpedanceControl.StartImpedance.value
+        self._dev.set_device_impedance_request(measurement_request)
+        self._sampling_thread.start()
+        self._conversion_thread.start()
+
+    @LogPerformances
+    def stop(self):
+        measurement_request = TMSiDevImpedanceRequest()
+        measurement_request.StartStop = ImpedanceControl.StopImpedance.value
+        self._dev.set_device_impedance_request(measurement_request)
+        self._sampling_thread.stop()
+        self._conversion_thread.stop()

packages/tmsi/build/lib/apex_sdk/device/threads/conversion_thread.py

@@ -0,0 +1,59 @@
+"""
+(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 conversion_thread.py 
+ * @brief 
+ * Conversion Thread interface.
+ */
+
+
+"""
+
+import threading
+import time
+
+
+class ConversionThread(threading.Thread):
+    def __init__(
+        self, conversion_function, pause=0.01, name="Conversion Thread"
+    ):
+        super().__init__()
+        self.__name = name
+        self.__conversion_function = conversion_function
+        self.__pause = pause
+
+    def get_pause(self):
+        return self.__pause
+
+    def run(self):
+        self.__converting = True
+        while self.__converting:
+            self.__conversion_function()
+            time.sleep(self.__pause)
+
+    def set_pause(self, pause):
+        self.__pause = pause
+
+    def stop(self):
+        self.__converting = False

packages/tmsi/build/lib/apex_sdk/device/threads/sampling_thread.py

@@ -0,0 +1,57 @@
+"""
+(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 sampling_thread.py 
+ * @brief 
+ * Sampling Thread interface
+ */
+
+
+"""
+
+import threading
+import time
+
+
+class SamplingThread(threading.Thread):
+    def __init__(self, sampling_function, pause=0.01, name="Sampling Thread"):
+        super().__init__()
+        self.__name = name
+        self.__sampling_function = sampling_function
+        self.__pause = pause
+
+    def get_pause(self):
+        return self.__pause
+
+    def run(self):
+        self.__sampling = True
+        while self.__sampling:
+            self.__sampling_function()
+            time.sleep(self.__pause)
+
+    def set_pause(self, pause):
+        self.__pause = pause
+
+    def stop(self):
+        self.__sampling = False

packages/tmsi/build/lib/apex_sdk/device/tmsi_channel.py

@@ -0,0 +1,83 @@
+"""
+(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 tmsi_channel.py 
+ * @brief 
+ * TMSi Channel interface.
+ */
+
+
+"""
+
+from .tmsi_device_enums import ChannelType
+
+
+class TMSiChannel:
+    def __init__(self):
+        self._alt_name = "-"
+        self._chan_divider = -1
+        self._def_name = "-"
+        self._enabled = False
+        self._exp = 0
+        self._format = 0
+        self._is_reference = 0
+        self._imp_divider = -1
+        self._sample_rate = 0
+        self._type = ChannelType.unknown
+        self._unit_name = "-"
+
+    def get_channel_exp(self):
+        return self._exp
+
+    def get_channel_format(self):
+        return self._format
+
+    def get_channel_name(self):
+        return self._alt_name
+
+    def get_channel_type(self):
+        return self._type
+
+    def get_channel_unit_name(self):
+        return self._unit_name
+
+    def is_reference(self):
+        if self._is_reference == 1:
+            return 1
+        else:
+            return 0
+
+    def set_device_channel_information(self):
+        raise NotImplementedError("method not available for this channel")
+
+    def set_device_channel_names(
+        self, default_channel_name=None, alternative_channel_name=None
+    ):
+        if default_channel_name is not None:
+            self._def_name = default_channel_name
+        if alternative_channel_name is not None:
+            self._alt_name = alternative_channel_name
+
+    def set_device_reference(self, is_reference):
+        self._is_reference = is_reference

packages/tmsi/build/lib/apex_sdk/device/tmsi_device.py

@@ -0,0 +1,201 @@
+"""
+(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 tmsi_device.py 
+ * @brief 
+ * TMSi Device interface.
+ */
+
+
+"""
+
+
+class TMSiDevice:
+    def __init__(self):
+        raise NotImplementedError("method not available for this device")
+
+    def close(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def discover(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def download_file_from_device(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def export_configuration(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def import_configuration(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_card_recording_config(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_card_status(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_active_channels(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_card_file_info(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_card_file_list(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_channels(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_data(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_handle_value(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_impedance_channels(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_impedance_data(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_info_report(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_interface_status(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_list(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_power_status(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_sampling_config(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_sampling_frequency(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_serial_number(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_state(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_time(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_device_type(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_dongle_list(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_dongle_serial_number(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_downloaded_percentage(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_dr_interface(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_event(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_event_buffer(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_id(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_live_impedance(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_num_channels(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_num_impedance_channels(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def get_sdk(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def open(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def pair_device(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def reset_device_card(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def reset_device_data_buffer(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def reset_device_event_buffer(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def reset_to_factory_default(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_card_recording_config(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_channel_names(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_download_file_request(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_impedance_request(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_interface(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_references(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_sampling_config(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_sampling_request(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def set_device_time(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def start_download_file(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def start_measurement(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def stop_download_file(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")
+
+    def stop_measurement(*args, **kwargs):
+        raise NotImplementedError("method not available for this device")