pyForceDAQ 2.0.0__py3-none-any.whl

pyforcedaq/__init__.py

@@ -0,0 +1,43 @@
+"""DAQ tool to record response force data
+
+Oliver Lindemann, 2026
+
+
+launch the GUI force from your Python program:
+``
+    from pyforcedaq import gui
+
+    gui.run_with_options(remote_control=False,
+              ask_filename=True,
+               calibration_file="FT_sensor1.cal")
+``
+
+
+import relevant stuff to program your own force:
+``
+    from pyforcedaq import force
+``
+
+import relevant stuff for remote control of the GUI force:
+``
+    from pyforcedaq import remote_control
+``
+
+For function to support data handling see the folder pyForceDAQ/analysis
+
+Oliver Lindemann
+"""
+
+__version__ = "2.0.beta"
+__author__ = "Oliver Lindemann"
+
+import sys as _sys
+
+USE_MOCK_SENSOR = False # <-- change for usage in lab to False
+
+if _sys.version_info[0] != 3 or _sys.version_info[1]<12:
+    raise RuntimeError("pyForceDAQ {0} ".format(__version__) +
+                      "is not compatible with Python {0}.{1}. ".format(
+                                                    _sys.version_info[0],
+                                                    _sys.version_info[1]) +
+                       "Please use Python 3.12+.")

pyforcedaq/__main__.py

@@ -0,0 +1,42 @@
+
+import argparse
+
+from . import __author__, __version__, gui
+
+
+def cli():
+
+    parser = argparse.ArgumentParser(
+        prog="forcedaq",
+        description="Command-line interface for pyforceDAQ",
+        epilog=f"Author: {__author__}",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    parser.add_argument("SETTINGS_FILE", nargs="?", default="", help="settings file")
+
+    parser.add_argument(
+        "-l", "--launcher",
+        action="store_true",
+        default=False,
+        help="Run with launcher GUI to edit settings and start recording",
+    )
+
+    args = parser.parse_args()
+
+    if args.launcher:
+        if len(args.SETTINGS_FILE) > 0:
+            print("Can't use launcher and settings file")
+            exit()
+
+        from .gui import launcher
+        return launcher.run()
+    else:
+        gui.run(args.SETTINGS_FILE)
+
+
+
+if __name__ == "__main__": # required because of threading
+    cli() # gui.run(), gui.run_with_options()

pyforcedaq/_lib/__init__.py

@@ -0,0 +1 @@
+__author__ = "Oliver Lindemann"

pyforcedaq/_lib/lsl.py

@@ -0,0 +1,56 @@
+from pylsl import (
+    StreamInfo,
+    StreamOutlet,
+    cf_double64,
+    cf_float32,
+    cf_int8,
+    cf_int16,
+    cf_int32,
+    cf_int64,
+    cf_string,
+    cf_undefined,
+)
+
+
+def init(
+    name: str,
+    n_channels: int,
+    stream_id: str,
+    freq: int,
+    channel_format: int,
+    metadata: dict | None = None,
+) -> StreamOutlet:
+    """
+    Initialise a LSL stream
+
+    Args:
+        name: name of the stream
+        n_channels: number of channels per sample
+        channel_format: format/type of each channel (ex: string, int, ...)
+                        same format for each channel
+        stream_id: unique identifier of the stream
+        content_type: content type of stream. By convention LSL uses the content
+            types defined in the XDF file format specification where
+            applicable
+        freq: sampling rate in Hz
+
+    Return:
+        outlet: StreamOulet to push samples with LSL
+    """
+    # LSL
+    # StreamInfo takes name t
+    info = StreamInfo(name, "force",
+                      channel_count=n_channels,
+                      nominal_srate=freq,
+                      channel_format=channel_format,
+                      source_id=stream_id)
+
+    # Check if there is metadata to add to the lsl stream
+    if metadata:
+        # Get xml object of the stream created earlier
+        xml_info = info.desc()
+        # Add meta data to xml object
+        for key, data in metadata.items():
+            xml_info.append_child_value(key, str(data))
+
+    return StreamOutlet(info)

pyforcedaq/_lib/misc.py

@@ -0,0 +1,126 @@
+from os import listdir, path
+
+from .timer import get_time_ms
+
+
+def N2g(N):
+    kg = N/9.81
+    return kg*1000
+
+class MinMaxDetector(object):
+
+    def __init__(self, start_value, duration):
+        self._minmax = [start_value, start_value]
+        self._duration = duration
+        self._level_change_time = None
+
+    def process(self, value):
+        """Returns minmax (tuple) for a number of samples after the first
+        level change has occurred, otherwise None"""
+
+        if self._level_change_time is not None:
+            if (get_time_ms() - self._level_change_time) >= self._duration:
+                return tuple(self._minmax)
+
+            if value > self._minmax[1]:
+                self._minmax[1] = value
+            elif value < self._minmax[0]:
+                self._minmax[0] = value
+
+        elif self._minmax[0] != value: # level change just occurred
+            self._level_change_time = get_time_ms()
+            return self.process(value)
+
+        return None
+
+    @property
+    def is_sampling_for_minmax(self):
+        """true true if currently sampling for minmax"""
+        return (self._level_change_time is not None) and \
+               (get_time_ms() - self._level_change_time) < self._duration
+
+def find_calibration_file(calibration_folder, sensor_name,
+                          calibration_suffix=".cal"):
+
+    needle = 'Serial="{0}"'.format(sensor_name)
+    for x in listdir(path.abspath(calibration_folder)):
+        filename = path.join(calibration_folder, x)
+        if path.isfile(filename) and filename.endswith(calibration_suffix):
+            with open(filename, "r") as fl:
+                for l in fl:
+                    if l.find(needle)>0:
+                        return filename
+    raise RuntimeError("Can't find calibration file for sensor '{0}' : {1}.".format(
+        sensor_name, filename))
+
+
+#Sensor History with moving average filtering and distance, velocity
+class SensorHistory(object):
+    """The Sensory History keeps track of the last n recorded sample and
+    calculates online the moving average (running mean).
+
+    SensorHistory.moving_average
+
+    """
+
+    def __init__(self, history_size, number_of_parameter):
+        self.history = [[0] * number_of_parameter] * history_size
+        self.moving_average = [0] * number_of_parameter
+        self._correction_cnt = 0
+        self._previous_moving_average = self.moving_average
+
+    def __str__(self):
+        return str(self.history)
+
+    def update(self, values):
+        """Update history and calculate moving average
+
+        (correct for accumulated rounding errors ever 10000 samples)
+
+        Parameter
+        ---------
+        values : list of values for all sensor parameters
+
+        """
+
+        self._previous_moving_average = self.moving_average
+        pop = self.history.pop(0)
+        self.history.append(values)
+        # pop first element and calc moving average
+        if self._correction_cnt > 10000:
+            self._correction_cnt = 0
+            self.moving_average = self.calc_history_average()
+        else:
+            self._correction_cnt += 1
+            self.moving_average = list(map(
+                lambda x: x[0] + (float(x[1] - x[2]) / len(self.history)),
+                zip(self.moving_average, values, pop)))
+
+
+    def calc_history_average(self):
+        """Calculate history averages for all sensor parameter.
+
+        The method is more time consuming than calling the property
+        `moving_average`. It is does however not suffer from accumulated
+        rounding-errors such as moving average.
+
+        """
+
+        s = [float(0)] * self.number_of_parameter
+        for t in self.history:
+            s = list(map(lambda x: x[0] + x[1], zip(s, t)))
+        return list(map(lambda x: x / len(self.history), s))
+
+
+    @property
+    def history_size(self):
+        return len(self.history)
+
+    @property
+    def number_of_parameter(self):
+        return len(self.history[0])
+
+    @property
+    def previous_moving_average(self):
+        return self._previous_moving_average
+

pyforcedaq/_lib/polling_time_profile.py

@@ -0,0 +1,52 @@
+import numpy as np
+
+from .timer import get_time_ms
+
+
+class PollingTimeProfile(object):
+
+    def __init__(self, timing_range=10):
+        self._last = None
+        self._timing_range = 10
+        self._zero_cnt = 0
+
+        #self._zero_time_polling_frequency = {}
+        self.profile_frequency = np.array([0] * (timing_range + 1))
+
+    def stop(self):
+        self._last = None
+
+    def update(self, time_ms):
+        if self._last is not None:
+            d = time_ms - self._last
+            if d > self._timing_range:
+                d = self._timing_range
+            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(get_time_ms())
+
+    @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/_lib/process_priority_manager.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+import gc
+import sys
+import psutil
+import logging
+
+from .types import PollingPriority
+
+_REALTIME_PRIORITY_CLASS = -18
+_HIGH_PRIORITY_CLASS = -10
+
+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
+
+    def __init__(self):
+        self._subprocs = []
+
+    def add_subprocess(self, process):
+        """add process or list of processes"""
+
+        if isinstance(process, (list, tuple)):
+            for x in process:
+                self.add_subprocess(x)
+            return
+
+        try:
+            pid = process.pid
+            self._subprocs.append(process)
+        except:
+            logging.warning("Can't add process: {}".format(process))
+
+    def get_subprocess_priorities(self):
+        """returns list with priorities"""
+
+        rtn = []
+        for p in self._subprocs:
+            if p.pid is not None:
+                rtn.append(get_priority(p.pid))
+            else:
+                rtn.append(None)
+
+        return rtn
+
+    def set_subprocess_priorities(self, level, disable_gc=False):
+
+        rtn = []
+        for p in self._subprocs:
+            if p.pid is not None:
+                rtn.append(set_priority(level=level, process_id=p.pid,
+                                        disable_gc=disable_gc))
+            else:
+                rtn.append(False)
+
+        return rtn
+
+
+    @staticmethod
+    def get_main_priority():
+        """
+            returning main process priority, if subprocess_id=None
+            Priority: 'normal', 'high', or 'realtime'
+        """
+
+        return get_priority(ProcessPriorityManager.main_process_id)
+
+    @staticmethod
+    def set_main_priority(level, disable_gc=False):
+        """
+            changing main process, if subprocess_id=None
+        """
+
+        return set_priority(level=level,
+                            process_id=ProcessPriorityManager.main_process_id,
+                            disable_gc=disable_gc)
+
+def get_priority(process_id):
+    """
+        returning main process priority, if subprocess_id=None
+        Priority: 'normal', 'high', or 'realtime'
+    """
+
+    try:
+        process = psutil.Process(process_id)
+    except:
+        return None
+
+    proc_priority = process.nice()
+    if ProcessPriorityManager.platform == 'win32':
+        if proc_priority == psutil.HIGH_PRIORITY_CLASS:
+            return PollingPriority.HIGH
+        elif proc_priority == psutil.REALTIME_PRIORITY_CLASS:
+            return PollingPriority.REALTIME
+
+    else:
+        if proc_priority <= _REALTIME_PRIORITY_CLASS:
+            return PollingPriority.REALTIME
+        elif proc_priority <= _HIGH_PRIORITY_CLASS:
+            return PollingPriority.HIGH
+
+    return PollingPriority.NORMAL
+
+def set_priority(level, process_id, disable_gc):
+
+    try:
+        process = psutil.Process(process_id)
+    except:
+        return False
+    nice_val = ProcessPriorityManager._normal_nice_value
+    level = PollingPriority.get_priority(level)
+
+    if level == PollingPriority.NORMAL:
+        disable_gc = False
+    elif level == PollingPriority.HIGH:
+        nice_val = _HIGH_PRIORITY_CLASS
+        if ProcessPriorityManager.platform == 'win32':
+            nice_val = psutil.HIGH_PRIORITY_CLASS
+    elif level == PollingPriority.REALTIME:
+        nice_val = _REALTIME_PRIORITY_CLASS
+        if ProcessPriorityManager.platform == 'win32':
+            nice_val = psutil.REALTIME_PRIORITY_CLASS
+
+    try:
+        process.nice(nice_val)
+        if disable_gc:
+            gc.disable()
+        else:
+            gc.enable()
+    except psutil.AccessDenied:
+        logging.warning('Could not set process {} priority '
+                  'to {} ({})'.format(process.pid, nice_val, level))
+
+    return True
+
+
+#    def getProcessAffinities(): TODO?
+#
+#       curproc_affinity = SubProcessPriorityManager.current_process.cpu_affinity()
+#        return curproc_affinity
+
+#    @staticmethod
+#    def setProcessAffinities(experimentProcessorList, ioHubProcessorList):
+#        SubProcessPriorityManager.current_process.cpu_affinity(experimentProcessorList)
+

pyforcedaq/_lib/timer.py

@@ -0,0 +1,45 @@
+"""A high-resolution monotonic timer
+
+Python 3.3+ provides the time.perf_counter() function, which is a high-resolution monotonic timer.
+"""
+
+__author__ = 'Florian Krause <florian@expyriment.org>, \
+Oliver Lindemann <oliver@expyriment.org>'
+__version__ = ''
+__revision__ = ''
+__date__ = ''
+
+from time import perf_counter, sleep
+
+
+def get_time_ms() -> int:
+    """Get high-resolution time stamp (int) """
+    return int(1000 * perf_counter())
+
+class Timer(object):#
+    """A simple clock class that can be used to measure elapsed time in milliseconds."""
+
+    def __init__(self, sync_timer=None):
+        if sync_timer is None:
+            self._init_time = get_time_ms()
+        else:
+            self._init_time = sync_timer._init_time
+
+    @property
+    def time(self):
+        return get_time_ms() - self._init_time
+
+
+def wait(waiting_time):
+    """Wait for a certain amount of milliseconds.
+    """
+
+    start = get_time_ms()
+    looptime = 200
+    if waiting_time > looptime:
+        sleep((waiting_time - looptime) / 1000)
+    while get_time_ms() < start + waiting_time:
+        pass
+
+
+app_clock = Timer()