pyForceDAQ 2.0.3.dev1__py3-none-any.whl → 2.0.5.dev2__py3-none-any.whl

pyforcedaq/__main__.py

@@ -1,8 +1,13 @@
 import argparse
 
-from . import __author__, __version__
+from . import __author__, __version__, constants
 
 
+def print_version():
+    print("+" + "-" * 23 + "+")
+    print(f"| pyforceDAQ {__version__}".ljust(24) + "|")
+    print("+" + "-" * 23 + "+")
+
 def cli():
 
     parser = argparse.ArgumentParser(
@@ -31,12 +36,29 @@ def cli():
         default=False,
         help="Omit launcher GUI and start recording directly",
     )
-    print("+" + "-" * 23 + "+")
-    print(f"| pyforceDAQ {__version__}".ljust(24) + "|")
-    print("+" + "-" * 23 + "+")
+
+    parser.add_argument(
+        "--mock",
+        action="store_true",
+        default=False,
+        help="Use mock sensor",
+    )
+
+    parser.add_argument(
+        "--dll",
+        action="store_true",
+        default=False,
+        help="Use self compiled ATI DLL",
+    )
 
     args = parser.parse_args()
+    if args.mock:
+        constants.DAQ_TYPE = constants.MOCK_SENSOR
+    else:
+        constants.DAQ_TYPE = constants.NIDAQMX # use NI-DAQmx
+    constants.USE_AIFTT = not args.dll
 
+    print_version()
     if not args.omit_launcher:
         if len(args.SETTINGS_FILE) > 0:
             print("Can't use launcher and settings file")
@@ -53,3 +75,4 @@ def cli():
 
 if __name__ == "__main__":  # required because of threading
     cli()
+    cli()

pyforcedaq/_lib/data_recorder.py

@@ -14,6 +14,7 @@ from time import asctime, localtime, strftime
 from typing import List
 
 from .. import __version__ as forceDAQVersion
+from .. import constants
 from .clock import wait_ms
 from .misc import set_logging
 from .process_priority_manager import ProcessPriorityManager
@@ -49,6 +50,11 @@ class DataRecorder(object):
 
         polling_priority has to be types.PollingPriority.{HIGH},
         {REALTIME} or {NORMAL} or None
+
+        You can change the used modules by settings the following constants before creating the
+        DataRecorder instance:
+            * set constants.DAQ_TYPE to constants.PYDAQMX, constants.NIDAQMX or constants.MOCK_SENSOR
+            * set constants.USE_AIFTT to True or False
         """
 
         if not isinstance(force_sensor_settings, list):
@@ -66,6 +72,8 @@ class DataRecorder(object):
                 fst = SensorProcess(
                     sensor_settings=fs,
                     recording_settings=recording_settings,
+                    daq_type=constants.DAQ_TYPE,
+                    use_aiftt=constants.USE_AIFTT,
                     pipe_buffered_data_after_pause=True,
                 )
                 fst.start()

pyforcedaq/_lib/process_priority_manager.py

@@ -16,7 +16,7 @@ class ProcessPriorityManager(object):
     platform = sys.platform
     pybits = 32 + int(sys.maxsize > 2**32) * 32
     main_process_id = psutil.Process().pid
-    _normal_nice_value = psutil.Process().nice()  # usied on Linux
+    _normal_nice_value = psutil.Process().nice()  # used on Linux
 
     def __init__(self):
         self._subprocs = []

pyforcedaq/_lib/sensor.py

@@ -7,38 +7,53 @@ __author__ = "Oliver Lindemann"
 
 import numpy as np
 
-from ..daq import CalibrationConverter, DAQReadAnalog
+from .. import constants
 from .clock import local_clock
 from .settings import SensorSettings
 from .types import ForceSensorData
 
 
-class Sensor(DAQReadAnalog):
+class Sensor(object):
     # channel 0:5 for FT sensor, channel 6  for trigger
     SENSOR_CHANNELS = range(0, 5 + 1)
     # channel 7 for trigger   synchronization validation
     TRIGGER_CHANNELS = range(5, 6 + 1)
 
-    def __init__(self, s_settings: SensorSettings):
+    def __init__(self, s_settings: SensorSettings,
+                 daq_type: int,
+                 use_aiftt: bool):
         """DOC"""
 
         assert isinstance(s_settings, SensorSettings)
         assert len(self.SENSOR_CHANNELS) == len(ForceSensorData.forces_names)
 
-        super(Sensor, self).__init__(
-            configuration=s_settings,
+        if daq_type == constants.NIDAQMX:
+            from ..daq.read_daq_nidaqmx import DAQReadAnalog
+        elif daq_type == constants.PYDAQMX:
+            from ..daq.read_daq_pydaqmx import DAQReadAnalog
+        elif daq_type == constants.MOCK_SENSOR:
+            from ..daq.read_daq_mock_sensor import DAQReadAnalog
+        else:
+            raise RuntimeError(f"Unsupported daq_type: {daq_type}")
+
+        if use_aiftt:
+            from ..daq.calibration_iaftt import CalibrationConverter
+        else:
+            from ..daq.calibration_dll import CalibrationConverter
+
+        self.daq = DAQReadAnalog(configuration=s_settings,
             read_array_size_in_samples=len(Sensor.SENSOR_CHANNELS)
-            + len(Sensor.TRIGGER_CHANNELS),
-        )
+            + len(Sensor.TRIGGER_CHANNELS))
 
-        self.sensor_id = s_settings.sensor_id
-        self.device_label = s_settings.device_label
-        self.convert_to_FT = s_settings.convert_to_FT
-        if self.DAQ_TYPE == "mock_sensor":
+        if daq_type == constants.MOCK_SENSOR:
             self._calib_converter = None
         else:
             self._calib_converter = CalibrationConverter(s_settings.calibration_file)
 
+        self.sensor_id = s_settings.sensor_id
+        self.device_label = s_settings.device_label
+        self.convert_to_FT = s_settings.convert_to_FT
+
         self._reverse_vector = np.ones(len(ForceSensorData.forces_names))
         if s_settings.reverse_parameter_names is not None:
             if isinstance(s_settings.reverse_parameter_names, str):
@@ -55,11 +70,11 @@ class Sensor(DAQReadAnalog):
     def determine_bias(self, n_samples=100):
         """determines the bias"""
 
-        task_was_running = self._task_is_started
-        self.start_data_acquisition()
+        task_was_running = self.daq.is_acquiring_data
+        self.daq.start_data_acquisition()
         data = None
         for _ in range(n_samples):
-            read_buffer, _read_samples = self.read_analog()
+            read_buffer, _ = self.daq.read_analog()
             sample = read_buffer[Sensor.SENSOR_CHANNELS]
             if data is None:
                 data = sample
@@ -67,7 +82,7 @@ class Sensor(DAQReadAnalog):
                 data = np.vstack((data, sample))
 
         if not task_was_running:
-            self.stop_data_acquisition()
+            self.daq.stop_data_acquisition()
 
         if self._calib_converter is not None and isinstance(data, np.ndarray):
             self._calib_converter.bias(np.mean(data, axis=0))
@@ -88,7 +103,7 @@ class Sensor(DAQReadAnalog):
         """
 
         start = local_clock()
-        data, _read_samples = self.read_analog()
+        data, _read_samples = self.daq.read_analog()
         if self.convert_to_FT and self._calib_converter is not None:
             forces = np.asarray(
                 self._calib_converter.convertToFT(voltages=data[Sensor.SENSOR_CHANNELS])
@@ -107,4 +122,4 @@ class Sensor(DAQReadAnalog):
             sensor_id=self.sensor_id,
             forces=forces,
             trigger=data[Sensor.TRIGGER_CHANNELS],
-        )
+        )

pyforcedaq/_lib/sensor_process.py

@@ -8,9 +8,9 @@ from multiprocessing import Array, Event, Pipe, Process, Value
 import numpy as np
 from numpy import typing as npt
 
+from .. import constants
 from .clock import local_clock, wait_ms
 from .lsl import LSLSream, cf_float32
-from .polling_time_profile import PollingTimeProfile
 from .process_priority_manager import get_priority
 from .sensor import Sensor
 from .settings import RecordingSettings, SensorSettings
@@ -22,6 +22,8 @@ class SensorProcess(Process):
         self,
         sensor_settings: SensorSettings,
         recording_settings: RecordingSettings,
+        daq_type: int,
+        use_aiftt: bool,
         pipe_buffered_data_after_pause=True,
         chunk_size=10000,
     ):
@@ -43,6 +45,12 @@ class SensorProcess(Process):
             )
 
         super(SensorProcess, self).__init__()
+
+        if daq_type not in [constants.NIDAQMX, constants.PYDAQMX, constants.MOCK_SENSOR]:
+            raise RuntimeError(f"Unsupported daq_type: {daq_type}")
+
+        self._daq_type = daq_type
+        self._use_aiftt = use_aiftt
         self.sensor_settings = sensor_settings
         self.recording_settings = recording_settings
         self._pipe_buffer_after_pause = pipe_buffered_data_after_pause
@@ -152,14 +160,16 @@ class SensorProcess(Process):
     def run(self):
         buffer = []
         self._buffer_size.value = 0
-        sensor = Sensor(self.sensor_settings)
+        sensor = Sensor(self.sensor_settings,
+                        daq_type=self._daq_type,
+                        use_aiftt=self._use_aiftt)
+
         stream_forces = self.recording_settings.array_write_forces()
         stream_trigger = self.recording_settings.array_write_trigger()
 
         self._event_is_polling.clear()
         self._event_sending_data.clear()
         is_polling = False
-        ptp = PollingTimeProfile()  # TODO just for testing?
 
         ## create init LSL
         lsl_data_steam = LSLSream()
@@ -190,7 +200,7 @@ class SensorProcess(Process):
                 if not is_polling:
                     # start NI device and acquire one first sample to
                     # ensure good timing
-                    sensor.start_data_acquisition()
+                    sensor.daq.start_data_acquisition()
                     buffer.append(
                         DAQEvents(
                             time=local_clock(), code="started:" + sensor.device_label
@@ -215,7 +225,6 @@ class SensorProcess(Process):
                     if any(tr):  # only stream if at least one trigger is active
                         lsl_hardware_trigger_stream.outlet.push_sample(tr)  # type: ignore
 
-                ptp.update(d.time)  # needed? TODO
                 self._dat[:] = d.forces
                 self._sample_cnt.value += 1  # type: ignore
 
@@ -230,7 +239,7 @@ class SensorProcess(Process):
             else:
                 # pause: not polling
                 if is_polling:
-                    sensor.stop_data_acquisition()
+                    sensor.daq.stop_data_acquisition()
                     buffer.append(
                         DAQEvents(
                             time=local_clock(), code="pause:" + sensor.device_label
@@ -244,7 +253,6 @@ class SensorProcess(Process):
                         get_priority(self.pid),
                     )
                     is_polling = False
-                    ptp.stop()
 
                 if self._pipe_buffer_after_pause and self._buffer_size.value > 0:
                     # sending data to force
@@ -268,10 +276,9 @@ class SensorProcess(Process):
                 self._event_is_polling.wait(timeout=0.1)
 
         # stop process
-        sensor.stop_data_acquisition()
+        sensor.daq.stop_data_acquisition()
         self._buffer_size.value = 0
 
-        logging.info("Sensor quit, %s, %s", sensor.device_label, ptp.get_profile_str())
-
+        logging.info("Sensor quit, %s", sensor.device_label)
 
 # FIXME check trigger processing and UDP connections#FIXME check trigger processing and UDP connections

pyforcedaq/_lib/settings.py

@@ -86,8 +86,8 @@ class RecordingSettings(ABCSettings):
     calibration_files: List[str] = field(default_factory=lambda: ["FT9334.cal"])
     calibration_folder: str = CALIBRATION_FOLDER
 
-    lsl_stream: bool = False
-    save_data: bool = True
+    lsl_stream: bool = True
+    save_data: bool = False
     sampling_rate: int = 1000
 
     write_Fx: bool = True

pyforcedaq/_lib/udp_connection.py

@@ -11,7 +11,6 @@ from multiprocessing import Event, Process, Queue
 from subprocess import check_output
 
 from .clock import local_clock, wait_ms
-from .polling_time_profile import PollingTimeProfile
 from .process_priority_manager import get_priority
 from .types import UDPData
 
@@ -275,7 +274,6 @@ class UDPConnectionProcess(Process):
         udp_connection = UDPConnection(udp_port=5005)
         self.start_polling()
 
-        ptp = PollingTimeProfile()
         prev_event_polling = None
 
         while not self._event_quit_request.is_set():
@@ -290,14 +288,12 @@ class UDPConnectionProcess(Process):
                     )
                 else:
                     logging.warning("UDP stop")
-                    ptp.stop()
 
             if not self._event_is_polling.is_set():
                 self._event_is_polling.wait(timeout=0.1)
             else:
                 data = udp_connection.poll()
                 t = local_clock()
-                ptp.update(t)
                 if data is not None:
                     d = UDPData(string=data, time=t)
                     self.receive_queue.put(d)
@@ -324,4 +320,4 @@ class UDPConnectionProcess(Process):
 
         udp_connection.unconnect_peer()
 
-        logging.warning("UDP quit, {}".format(ptp.get_profile_str()))
+        logging.warning("UDP quit")

pyforcedaq/constants.py

@@ -1,6 +1,9 @@
-USE_MOCK_SENSOR = False # <-- change for usage in lab to False
-USE_PYDAQMX = False # <-- change to True to use pyDAQmx instead of nidaqmx, requires pyDAQmx installation
-USE_ATI_DLL = False # <-- change to True to use ATI DLL for calibration conversion, otherwise use atiiaftt
+NIDAQMX = 1
+PYDAQMX = 2
+MOCK_SENSOR = 9
+
+DAQ_TYPE = NIDAQMX # default to nidaqmx, use constants.MOCK_SENSOR for mock sensor, constants.PYDAQMX for PyDAQmx
+USE_AIFTT = True # <-- change to False to use ATI DLL for calibration conversion, otherwise use atiiaftt
 
 SETTINGS_FILE_EXTENSION = ".settings.toml"
 DEFAULT_SETTINGS_FILE = "pyForceDAQ" + SETTINGS_FILE_EXTENSION

pyforcedaq/daq/__init__.py

@@ -1,28 +1,68 @@
 __author__ = "Oliver Lindemann"
 
-from ..constants import USE_ATI_DLL, USE_MOCK_SENSOR, USE_PYDAQMX
-
-if USE_MOCK_SENSOR:
-    print("Using mock sensor instead.")
-    from ._mock_sensor import DAQReadAnalog
-
-else:
-    try:
-        if USE_PYDAQMX:
-            print("Using PyDAQmx for DAQ access.")
-            from ._use_pydaqmx import DAQReadAnalog
-        else:
-            print("Using nidaqmx for DAQ access.")
-            from ._use_nidaqmx import DAQReadAnalog
-    except (ImportError, ModuleNotFoundError, NotImplementedError) as e:
-        print("Error importing DAQReadAnalog: {0}".format(e))
-        print("Warning: PyDAQmx or nidaqmx not found. Using mock sensor instead.")
-        from ._mock_sensor import DAQReadAnalog
-
-if not USE_ATI_DLL:
-    print("Using ATI IAFTT for calibration conversion.")
-    from ._calibration_iaftt import CalibrationConverter
-
-else:
-    print("ATI_CDLL for calibration conversion.")
-    from ._calibration_dll import CalibrationConverter
+from abc import ABC, abstractmethod
+from typing import Tuple
+
+import numpy.typing as npt
+
+from .._lib.settings import DAQConfiguration
+
+
+class DAQReadAnalogABC(ABC):
+    """Abstract base class for DAQ analog reading."""
+
+    @abstractmethod
+    def __init__(self,
+                 configuration: DAQConfiguration,
+                 read_array_size_in_samples: int):
+        """Initialize the DAQ device."""
+        pass
+
+    @property
+    @abstractmethod
+    def is_acquiring_data(self) -> bool:
+        """Return whether data acquisition is in progress."""
+        pass
+
+
+    @abstractmethod
+    def start_data_acquisition(self) -> None:
+        """Start data acquisition."""
+        pass
+
+    @abstractmethod
+    def stop_data_acquisition(self) -> None:
+        """Stop data acquisition."""
+        pass
+
+    @abstractmethod
+    def read_analog(self) -> Tuple[npt.NDArray, int]:
+        """Read analog data.
+
+        Returns
+        -------
+        read_buffer : numpy array
+            The read data.
+        read_samples : int
+            The number of samples actually read.
+        """
+        pass
+
+
+class CalibrationConverterABC(ABC):
+    """Abstract base class for Calibration Converters."""
+
+    @abstractmethod
+    def __init__(self, calibration_file: str):
+        """Initialize the calibration converter with a calibration file."""
+        pass
+
+    @abstractmethod
+    def convertToFT(self, voltages: npt.NDArray) -> list:
+        """Convert voltages to force and torque values."""
+        pass
+
+    @abstractmethod
+    def bias(self, bias_values: npt.NDArray) -> None:
+        """Set the bias for the calibration."""
+        pass

pyforcedaq/daq/{_calibration_dll.py → calibration_dll.py}

@@ -1,19 +1,21 @@
 import ctypes as ct
-from typing import List
 
 from numpy.typing import NDArray
 
+from . import CalibrationConverterABC
 from ._pyATIDAQ import ATI_CDLL
 
+print("Using self compiled ATI DLL for calibration conversion.")
+
+class CalibrationConverter(CalibrationConverterABC):
 
-class CalibrationConverter(object):
     def __init__(self, calibration_file: str):
         self._atidaq = ATI_CDLL()
         self._atidaq.createCalibration(calibration_file, ct.c_short(1))
         self._atidaq.setForceUnits("N")
         self._atidaq.setTorqueUnits("N-m")
 
-    def convertToFT(self, voltages: NDArray):
+    def convertToFT(self, voltages: NDArray) -> list:
         return self._atidaq.convertToFT(voltages)
 
     def bias(self, bias_values: NDArray):

pyforcedaq/daq/calibration_iaftt.py

@@ -0,0 +1,17 @@
+import atiiaftt
+from numpy.typing import NDArray
+
+from . import CalibrationConverterABC
+
+print("Using ATI IAFTT for calibration conversion.")
+
+class CalibrationConverter(CalibrationConverterABC):  # type: ignore
+
+    def __init__(self, calibration_file:str):
+        self._ftsensor = atiiaftt.FTSensor(calibration_file, index=1)
+
+    def convertToFT(self, voltages:NDArray) -> list:
+        return self._ftsensor.convertToFt(voltages.tolist()) #TODO: to list needed?
+
+    def bias(self, bias_values: NDArray) -> None:
+        self._ftsensor.bias(bias_values.tolist())

pyforcedaq/daq/{_mock_sensor.py → read_daq_mock_sensor.py}

@@ -6,9 +6,11 @@ from typing import Tuple
 import numpy as np
 
 from .._lib.clock import StopWatch
+from . import DAQReadAnalogABC
 
+print("Using mock sensor!!")
 
-class DAQReadAnalog(object):
+class DAQReadAnalog(DAQReadAnalogABC):
     NUM_SAMPS_PER_CHAN =  1
     TIMEOUT = 1.0
     NI_DAQ_BUFFER_SIZE = 1000
@@ -69,7 +71,7 @@ class DAQReadAnalog(object):
 
         # fill in data
         if not self._task_is_started:
-            return None, None
+            return np.array([]), 0
 
         n_new_samples = int(self._simulation_timer.time_ms) - self._sample_cnt
         while n_new_samples <= 0: # wait until new sample is available

pyforcedaq/daq/{_use_nidaqmx.py → read_daq_nidaqmx.py}

@@ -5,15 +5,18 @@ import numpy as np
 from nidaqmx import constants as nidaq_consts
 
 from .._lib.settings import DAQConfiguration
+from . import DAQReadAnalogABC
 
+print("Using nidaqmx for DAQ access.")
 
-class DAQReadAnalog(nidaqmx.Task):
+class DAQReadAnalog(nidaqmx.Task, DAQReadAnalogABC):
     NUM_SAMPS_PER_CHAN = 1
     TIMEOUT = 1
     DAQ_TYPE = "nidaqmx"
 
     def __init__(
-        self, configuration: DAQConfiguration, read_array_size_in_samples: int
+        self, configuration: DAQConfiguration,
+        read_array_size_in_samples: int
     ):
         """DOC
         read_array_size_in_samples for ReadAnalogF64 call
@@ -43,10 +46,10 @@ class DAQReadAnalog(nidaqmx.Task):
         self.read_array_size_in_samples = read_array_size_in_samples
 
     @property
-    def is_acquiring_data(self):
+    def is_acquiring_data(self) -> bool:
         return self._task_is_started
 
-    def start_data_acquisition(self):
+    def start_data_acquisition(self) -> None:
         """Start data acquisition of the NI device
         call always before polling
 
@@ -56,7 +59,7 @@ class DAQReadAnalog(nidaqmx.Task):
             self.start()
             self._task_is_started = True
 
-    def stop_data_acquisition(self):
+    def stop_data_acquisition(self) -> None:
         """Stop data acquisition of the NI device"""
 
         if self._task_is_started:
@@ -83,6 +86,6 @@ class DAQReadAnalog(nidaqmx.Task):
         """
 
         # fill in data
-        data = self.read(self.NUM_SAMPS_PER_CHAN, self.TIMEOUT)
+        data = self.read(self.NUM_SAMPS_PER_CHAN, self.TIMEOUT) # type: ignore
         np_data = np.reshape(np.array(data), (-1,))  # reshape to vector
         return np_data, len(np_data)

pyforcedaq/daq/{_use_pydaqmx.py → read_daq_pydaqmx.py}

@@ -16,9 +16,11 @@ import numpy as np
 import PyDAQmx
 
 from .._lib.settings import DAQConfiguration
+from . import DAQReadAnalogABC
 
+print("Using PyDAQmx for DAQ access.")
 
-class DAQReadAnalog(PyDAQmx.Task):
+class DAQReadAnalog(PyDAQmx.Task, DAQReadAnalogABC):
     NUM_SAMPS_PER_CHAN = ct.c_int32(1)
     TIMEOUT = ct.c_longdouble(1.0)  # one second
     NI_DAQ_BUFFER_SIZE = 1000
@@ -100,7 +102,7 @@ class DAQReadAnalog(PyDAQmx.Task):
         """
 
         # fill in data
-        read_samples = ct.c_int32()
+        read_samples = ct.c_int32(0)
         read_buffer = np.zeros((self.read_array_size_in_samples,), dtype=np.float64)
 
         error = self.ReadAnalogF64(

pyforcedaq/launcher.py

@@ -4,11 +4,10 @@ from typing import List
 
 import PySimpleGUI as _sg
 
-from . import __version__
+from . import __version__, constants
 from ._lib.misc import list_settings_files
 from ._lib.settings import AppSettings
 from ._lib.udp_connection import UDPConnection
-from .constants import DEFAULT_SETTINGS_FILE, USE_MOCK_SENSOR
 
 
 def _check_sensor_calibration_settings(
@@ -66,7 +65,7 @@ def _windows_run(settings: AppSettings):
     info = [[_sg.Text(f"version: {__version__}")]]
     info.append([_sg.Text(f"IP address: {UDPConnection.MY_IP}")])
 
-    if USE_MOCK_SENSOR:
+    if constants.DAQ_TYPE == constants.MOCK_SENSOR:
         info.append([_sg.Text("!!!  USING MOCK SENSORS  !!!", text_color="red")])
 
     layout = [
@@ -78,7 +77,7 @@ def _windows_run(settings: AppSettings):
                 key="Start",
             )
         ],
-        [_sg.Frame("Info", size=(280, 80), layout=info)],
+        [_sg.Frame("Info", size=(280, 150), layout=info)],
         [_sg.Frame("Settings", size=(280, 140), expand_y=True, layout=info_settings)],
     ]
     layout.append(
@@ -140,7 +139,7 @@ def load_settings_file(settings_file: str | Path) -> AppSettings:
 
 def run_launcher():
     _sg.theme("DarkBlue14")  # please make your windows colorful
-    settings = load_settings_file(DEFAULT_SETTINGS_FILE)
+    settings = load_settings_file(constants.DEFAULT_SETTINGS_FILE)
 
     while True:
         event, values, settings = _windows_run(settings)

{pyforcedaq-2.0.3.dev1.dist-info → pyforcedaq-2.0.5.dev2.dist-info}/METADATA

@@ -1,18 +1,15 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.3.dev1
+Version: 2.0.5.dev2
 Summary: A Python package for data acquisition and analysis in force-based experiments.
 Author: Oliver Lindemann
 Author-email: Oliver Lindemann <lindemann@essb.eur.nl>
 Requires-Dist: atiiaftt>=0.1.1
 Requires-Dist: expyriment>=1.0.1
-Requires-Dist: icecream>=2.2.0
 Requires-Dist: nidaqmx>=1.5.0
 Requires-Dist: numpy>=2.4.4
 Requires-Dist: psutil>=7.2.2
-Requires-Dist: pydaqmx>=1.4.7
 Requires-Dist: pylsl>=1.18.2
 Requires-Dist: pysimplegui>=6.0
-Requires-Dist: pyxdf>=1.17.4
 Requires-Dist: tomlkit>=0.15.0
 Requires-Python: >=3.12, <3.14

{pyforcedaq-2.0.3.dev1.dist-info → pyforcedaq-2.0.5.dev2.dist-info}/RECORD

@@ -1,25 +1,24 @@
 pyforcedaq/__init__.py,sha256=XlQ9TuycbGbJSN0p36XShcf22ETQ_JfftqHejS-C_oI,853
-pyforcedaq/__main__.py,sha256=GF4RJZGOvNKcToHal4zayh3j2vIY2wgNYeJQCb8h1vM,1377
+pyforcedaq/__main__.py,sha256=N_gT06qOd6WxZDO5_hfoksqGRFsT_cKLoIndkdnvfi0,1897
 pyforcedaq/_lib/__init__.py,sha256=GBiextmC_Xz9iMQlLBnU1qsw7YFVQaiZ8nV5ln3B7Wk,32
 pyforcedaq/_lib/clock.py,sha256=2QrQ5J_FAWH_RndM5mnBUVZUxiPaK1nCxRzzFL0zvkY,978
-pyforcedaq/_lib/data_recorder.py,sha256=Cf91hv4mxhrHfNsO_5l3eYarPK4dmo73aJGL9LaoSRI,13371
+pyforcedaq/_lib/data_recorder.py,sha256=JeiUMd4mSaAlyb-xZTC5hMLgLJlS0w98nuOD6VaMRiE,13781
 pyforcedaq/_lib/lsl.py,sha256=3hUq5DH7nVe-vjq-8w6VvXJhIGwkQdsTkK7pBSM4vu4,2096
 pyforcedaq/_lib/misc.py,sha256=9vfm7GOCrR4ddhTvmjtF3rCgoyLE0Ys1L8wfyhObzls,5450
-pyforcedaq/_lib/polling_time_profile.py,sha256=iHoRg78y1IkJHJLCT2LNjJHLauH5FWnz4RbxU20HRUA,1591
-pyforcedaq/_lib/process_priority_manager.py,sha256=MDA-E6kaYgBNtyEsHc1bLSrpQjSkrLZjB8Z7gCV5oo4,4196
-pyforcedaq/_lib/sensor.py,sha256=cEY9w88MzGQzAA92MBZ_LeZ_tXyR4jvYOP47Fv6DF-Q,3684
-pyforcedaq/_lib/sensor_process.py,sha256=BSSJ8QzSG9kqZZ1MiGXozqiUK6fgXz9oXww6I0Frd9k,9708
-pyforcedaq/_lib/settings.py,sha256=nHq9CVzafBw_HPaCMZjv-03cAGK9CwC9YzoJiapH4f4,6826
+pyforcedaq/_lib/process_priority_manager.py,sha256=eRDzhW7sCINRRo5sm40E88w0EHtOuLGrCt1Co18dm0w,4195
+pyforcedaq/_lib/sensor.py,sha256=Oay70h46U-hIaIEJtsSf2TvFKtBpnlasp4fuHzJVmBk,4276
+pyforcedaq/_lib/sensor_process.py,sha256=WdzlDj0VnJfWvxOq_zbSgCFvAesWE-ltAytwejRix3s,9900
+pyforcedaq/_lib/settings.py,sha256=0aI2iIn8s4AD_i1SaD1hTQzFQ1A8zi6nUoNjEs4EfGk,6826
 pyforcedaq/_lib/types.py,sha256=DS3-g1JYM_xi_q6YZJRr-BD2WX1fcKhDN6w4Y4l8d_M,10041
-pyforcedaq/_lib/udp_connection.py,sha256=FznfKS9vppEjivPgi9rHRxiT0HCB14x173QMUjNy5Kc,10061
-pyforcedaq/constants.py,sha256=Pu4zcT-RS3Qxxi8QNW2lIPsEo6_iOizgeOa87lJ2qeg,470
-pyforcedaq/daq/__init__.py,sha256=HVnOCs9q5uVHYZVSzCa-inZSR-D9RNVXzm16cdeotPo,977
-pyforcedaq/daq/_calibration_dll.py,sha256=HeGYX8TaJu6XbVGtHWLUydI74tW6UisjNr3sk7FN0t4,564
-pyforcedaq/daq/_calibration_iaftt.py,sha256=E4KsW9OhLhmWYtkFvj-RHKJq_MWioRjbTXVT0f6iwCE,501
-pyforcedaq/daq/_mock_sensor.py,sha256=KhbQ8CiIN5UNbYrg7O7NjKvlI8EjA8na2w2vR07MGq0,2192
+pyforcedaq/_lib/udp_connection.py,sha256=N3TRuW8kTTx7vwKHQaXsReFiGQAy5Dpr3eLG1ThPYdk,9878
+pyforcedaq/constants.py,sha256=EXED-LTh61cQ1wv_Dpfk-Svh3UtmN6DCuBW1rfGjISk,454
+pyforcedaq/daq/__init__.py,sha256=f5Uj85LlWEyxB-vElYvBsFFMSxK_8BhojzeGaRxn7jg,1677
 pyforcedaq/daq/_pyATIDAQ.py,sha256=XZqPoTCX73ZoosocZB_pxqKr-icUUFOONRd94pHTMQs,10834
-pyforcedaq/daq/_use_nidaqmx.py,sha256=OPUmWbvVNsDUcdKB2tZksMObCGJDrsxHG2s8u67KcG4,2397
-pyforcedaq/daq/_use_pydaqmx.py,sha256=QhvgRIbdaVKPMfHxveK004bJV0mWftzUwkqm-PJaCVg,3164
+pyforcedaq/daq/calibration_dll.py,sha256=QVQkJ57Za9Z-dIUzyqnCtBDRu-Au7WyKwKXjQ6qOYAU,669
+pyforcedaq/daq/calibration_iaftt.py,sha256=ms0Nt_6_H5ddez29LJsVSZSD3ShA3hglpz_rNP3Mi2w,567
+pyforcedaq/daq/read_daq_mock_sensor.py,sha256=RV4RJanU87oE_SK4i8NF3tsQoCTGzvgTpdYl7jX-y0E,2267
+pyforcedaq/daq/read_daq_nidaqmx.py,sha256=XUqJoCGzpSfjfMjatQqGHa3pBpQaIsbqL0B3Tz6OCps,2532
+pyforcedaq/daq/read_daq_pydaqmx.py,sha256=89BRuLhvVplKoBENuKlEUpG5CN25PrN__oWAm-k1Q4s,3253
 pyforcedaq/extras/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyforcedaq/extras/convert.py,sha256=N8r5gl0Te3GHafkggeC4btFD94nUwBzM9cctH1jiSEA,8601
 pyforcedaq/extras/read_force_data.py,sha256=ZjrEHexz40OW8L8JlRFgAFxQuBAS8c66t2-jVN9NeBg,2147
@@ -33,8 +32,8 @@ pyforcedaq/gui/_plotter.py,sha256=wVgy3ovX4BeXKJpuxYTw-xJ1lC4GzNni2exojzlhgAM,82
 pyforcedaq/gui/_run.py,sha256=BHeFiXtqnCiYkrBJxwyCKC5z91ERAfEwf8stckZVBEQ,18692
 pyforcedaq/gui/_scaling.py,sha256=mb9OMGqqS9_cOaYtdMqjGIS8VRrEQlDBc4m6KZF5TVQ,1918
 pyforcedaq/gui/forceDAQ_logo.png,sha256=-bn6ZQQjKf2Pxd9mJ4r-wulibtjuv_bEkhG567GR1vc,15624
-pyforcedaq/launcher.py,sha256=CnTRqjUZbLVwAUk5xHrfDC7Uxs4obOHKIkm8ZlJrVfE,4970
-pyforcedaq-2.0.3.dev1.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
-pyforcedaq-2.0.3.dev1.dist-info/entry_points.txt,sha256=0VDGqAldPs3uUCun3y9v4ue8Uae8n-D6-R5YpamgJwQ,56
-pyforcedaq-2.0.3.dev1.dist-info/METADATA,sha256=5oxwMRa8HtILboqaEkY1Aui_X9b_fN66dNUKFZqQ0PA,591
-pyforcedaq-2.0.3.dev1.dist-info/RECORD,,
+pyforcedaq/launcher.py,sha256=Tph9wdYQZcFOezFbp6MUHrKCCkGe6eMijMZFQ2u4xRY,4958
+pyforcedaq-2.0.5.dev2.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
+pyforcedaq-2.0.5.dev2.dist-info/entry_points.txt,sha256=0VDGqAldPs3uUCun3y9v4ue8Uae8n-D6-R5YpamgJwQ,56
+pyforcedaq-2.0.5.dev2.dist-info/METADATA,sha256=TtD6QzyYFDaCAJQpka2u5tKhMs3ENzlJNFObMTFgSQs,501
+pyforcedaq-2.0.5.dev2.dist-info/RECORD,,

pyforcedaq/_lib/polling_time_profile.py

@@ -1,57 +0,0 @@
-import numpy as np
-
-from .clock import local_clock
-
-
-class PollingTimeProfile(object):
-    def __init__(self, timing_range_ms=10):
-        self._last = None
-        self._timing_range_ms = 10
-        self._zero_cnt = 0
-
-        # self._zero_time_polling_frequency = {}
-        self.profile_frequency = np.array([0] * (timing_range_ms + 1))
-
-    def stop(self):
-        self._last = None
-
-    def update(self, time: float):
-
-        time_ms = int(time * 1000)
-        if self._last is not None:
-            d = time_ms - self._last
-            if d > self._timing_range_ms:
-                d = self._timing_range_ms
-            self.profile_frequency[d] += 1
-
-            # if d == 0:
-            #    self._zero_cnt += 1
-            # elif self._zero_cnt > 0:
-            #    try:
-            #        self._zero_time_polling_frequency[self._zero_cnt] += 1
-            #    except:
-            #        self._zero_time_polling_frequency[self._zero_cnt] = 1
-            #    self._zero_cnt = 0
-
-        self._last = time_ms
-
-    def tick(self):
-        self.update(local_clock())
-
-    @property
-    def profile_percent(self):
-        n = np.sum(self.profile_frequency)
-        return self.profile_frequency / n
-
-    def get_profile_str(self):
-        rtn = (
-            str(list(self.profile_frequency))
-            .replace("[", "")
-            .replace("]", "")
-            .replace(" ", "")
-        )
-        return "polling profile [{}]".format(rtn)
-
-    # @property
-    # def zero_time_polling_frequency(self):
-    #    return np.array(list(self._zero_time_polling_frequency.items()))

pyforcedaq/daq/_calibration_iaftt.py

@@ -1,17 +0,0 @@
-from typing import List
-
-import atiiaftt
-from numpy.typing import NDArray
-
-
-class CalibrationConverter(object):  # type: ignore
-
-    def __init__(self, calibration_file:str):
-        self._ftsensor = atiiaftt.FTSensor(calibration_file, index=1)
-
-    def convertToFT(self, voltages:NDArray):
-        return self._ftsensor.convertToFt(voltages.tolist()) # FIXME reverse parameter
-        #TODO: to list needed?
-
-    def bias(self, bias_values: NDArray):
-        self._ftsensor.bias(bias_values.tolist())