pyForceDAQ 2.0.6__tar.gz → 2.0.7__tar.gz

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.6
+Version: 2.0.7
 Summary: A Python package for data acquisition and analysis in force-based experiments.
 Author: Oliver Lindemann
 Author-email: Oliver Lindemann <lindemann@essb.eur.nl>

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyForceDAQ"
-version = "2.0.6"
+version = "2.0.7"
 description = "A Python package for data acquisition and analysis in force-based experiments."
 authors = [
     { name = "Oliver Lindemann", email = "lindemann@essb.eur.nl" },

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/data_recorder.py

@@ -14,12 +14,12 @@ from typing import List
 from .. import __version__ as forceDAQVersion
 from .. import constants
 from .file_writer import FileWriter
+from .lsl import LSLSream, cf_string
 from .misc import set_logging
 from .process_priority_manager import ProcessPriorityManager
 from .sensor_process import SensorProcess
 from .settings import RecordingSettings, SensorSettings
-from .types import DAQEvents, ForceSensorData, PollingPriority
-from .udp_connection import UDPConnectionProcess
+from .types import ForceSensorData, PollingPriority
 
 set_logging(data_directory="data", log_file="recording.log")
 
@@ -27,14 +27,12 @@ set_logging(data_directory="data", log_file="recording.log")
 
 
 class DataRecorder(object):
-    """handles multiple sensors and udp connection"""
+    """handles multiple sensors, file writing and process management, LSL stream for events"""
 
     def __init__(
         self,
         recording_settings: RecordingSettings,
-        force_sensor_settings: SensorSettings | List[SensorSettings],
-        poll_udp_connection: bool = False,
-    ):
+        force_sensor_settings: SensorSettings | List[SensorSettings]):
         """queue_data will be saved
         see sensorprocess.__init__
 
@@ -74,17 +72,23 @@ class DataRecorder(object):
                 fst.start()
                 event_trigger.append(fst.event_trigger)
                 self.force_sensor_processes.append(fst)
+        # LSL stream
+        self.lsl_events_stream = LSLSream()
+        if self.recording_settings.lsl_stream:
+            self.lsl_events_stream.init(
+                    name="Events_forceDAQ",
+                    content_type="Marker",
+                    n_channels=1,
+                    stream_id="FE",
+                    freq=0,
+                    channel_format=cf_string,
+                    metadata={}
+                )
+
 
-        # create udp connection process
-        if poll_udp_connection:
-            self.udp = UDPConnectionProcess(event_trigger=event_trigger)
-            self.udp.start()
-        else:
-            self.udp = None
 
         # process managing FIYME needed?
         self._proc_manager = ProcessPriorityManager()
-        self._proc_manager.add_subprocess(self.udp)
         self._proc_manager.add_subprocess(self.force_sensor_processes)
         if self.recording_settings.priority is not None:
             level = PollingPriority.NORMAL
@@ -96,8 +100,6 @@ class DataRecorder(object):
             "Main process priority: %s", self._proc_manager.get_main_priority()
         )
         # logging.info("Subprocess priorities: {}".format(self._proc_manager.get_subprocess_priorities()))
-
-        self._daq_event = [] # FIXME needed?
         atexit.register(self.quit)
 
     @property
@@ -145,37 +147,8 @@ class DataRecorder(object):
             fsp.join()
         self.close_data_file()
 
-        if self.udp is not None:
-            self.udp.quit()
-
         logging.info("Quit recording")
 
-    def process_and_write_udp_events(self) -> list:
-        """process udp events and return them"""
-        buffer = []
-        while True:
-            try:
-                data = self.udp.receive_queue.get_nowait()  # type: ignore
-            except AttributeError:
-                # until queue empty or no udp connection
-                break
-            buffer.append(data)
-
-        if isinstance(self.file_writer, FileWriter):
-            for dat in buffer:
-                self.file_writer.queue.put(dat)
-        return buffer
-
-    def store_daq_event(
-        self, code: str | int | float, time: float | None = None
-    ) -> None:
-        """Set marker code in file
-
-        DAQEvent will be timestamps and occur in the data output
-
-        """
-        self._daq_event.append(DAQEvents(time=time, code=code))
-
     def start_saving(self) -> None:
         """Start polling process and record
 
@@ -188,6 +161,7 @@ class DataRecorder(object):
         for fsp in self.force_sensor_processes:
             fsp.flag_sensor_bias_is_determined.wait() # wait is no initial bias is set yet
             fsp.start_saving()
+        self.lsl_events_stream.push_sample(["Start saving"])
 
     def pause_saving(self):
         """Pauses all polling processes and process data
@@ -201,6 +175,7 @@ class DataRecorder(object):
         # pause polling
         for fsp in self.force_sensor_processes:
             fsp.pause_saving()
+        self.lsl_events_stream.push_sample(["Pause saving"])
 
 
     def determine_biases(self) -> None:
@@ -208,6 +183,8 @@ class DataRecorder(object):
             x.determine_bias()
         for x in self.force_sensor_processes:
             x.flag_sensor_bias_is_determined.wait()
+        self.lsl_events_stream.push_sample(["New Baseline"])
+
 
     def open_data_file(
         self,
@@ -303,7 +280,9 @@ class DataRecorder(object):
 
         """
         if isinstance(self.file_writer, FileWriter):
+            self.pause_saving()
             self.file_writer.close_file()
             if self.file_writer.is_alive():
                 self.file_writer.join()
             self.file_writer.filepath = Path("")
+

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/file_writer.py

@@ -4,8 +4,7 @@ from pathlib import Path
 from queue import Empty
 
 from .settings import RecordingSettings
-from .types import (TAG_COMMENTS, TAG_DAQEVENT, TAG_UDPDATA, DAQEvents,
-                    ForceSensorData, UDPData)
+from .types import TAG_COMMENTS, ForceSensorData
 
 NEWLINE = "\n"
 ENCODING = "utf-8"
@@ -90,11 +89,6 @@ class FileWriter(Process):
                         txt += float_format.format(x)
                 txt = txt[:-1] + NEWLINE
 
-            elif isinstance(d, DAQEvents):
-                txt = f"{TAG_DAQEVENT},{d.time},{str(d.code)}{NEWLINE}"
-
-            elif isinstance(d, UDPData):
-                txt = f"{TAG_UDPDATA},{d.time},{d.unicode}{NEWLINE}"
             elif isinstance(d, str):
                 txt = f"{TAG_COMMENTS} {d}"
             else:

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/lsl.py

@@ -1,3 +1,6 @@
+from typing import List
+
+from numpy import typing as npt
 from pylsl import (
     StreamInfo,
     StreamOutlet,
@@ -24,6 +27,7 @@ class LSLSream:
     def init(
         self,
         name: str,
+        content_type: str,
         n_channels: int,
         stream_id: str,
         freq: int,
@@ -35,12 +39,13 @@ class LSLSream:
 
         Args:
             name: name of the stream
+            content_type: content type of stream. By convention LSL uses the content
+                types defined in the XDF file format specification where
             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
 
@@ -51,8 +56,7 @@ class LSLSream:
             return
 
         info = StreamInfo(
-            name,
-            "force",
+            name, content_type,
             channel_count=n_channels,
             nominal_srate=freq,
             channel_format=channel_format,
@@ -70,7 +74,7 @@ class LSLSream:
         self._is_init = True
         self.outlet = StreamOutlet(info)
 
-    def push_sample(self, sample: list):
+    def push_sample(self, sample: List | npt.NDArray):
         """Push a sample to the LSL stream if it is initialized."""
         if not self._is_init:
             # Don't do anything

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/misc.py

@@ -1,7 +1,12 @@
 import logging
 import os
+import socket
 import sys
 from pathlib import Path
+from subprocess import check_output
+
+import numpy as np
+from numpy import typing as npt
 
 from ..constants import SETTINGS_FILE_EXTENSION
 from .clock import local_clock_ms
@@ -67,32 +72,26 @@ class MinMaxDetector(object):
             local_clock_ms() - self._level_change_time
         ) < self._duration_ms
 
+def get_lan_ip():
+    if os.name == "nt":
+        # Windows
+        return socket.gethostbyname(socket.gethostname())
+    else:
+        # Linux and macOS
+        try:
+            # Try Linux command first
+            rtn = check_output(["hostname", "-I"]).decode().strip()
+            return rtn.split()[0] if rtn else None
+        except:
+            try:
+                # Fallback to macOS command
+                rtn = check_output(["ipconfig", "getifaddr", "en0"]).decode().strip()
+                return rtn if rtn else None
+            except:
+                # Fallback to socket method if both commands fail
+                return socket.gethostbyname(socket.gethostname())
+
 
-# def find_calibration_file(calibration_folder: str, device_label: str,
-#                           calibration_suffix=".cal") -> str:
-
-#     needle = 'Serial="{0}"'.format(device_label)
-#     calibration_files = []
-#     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:
-#                         print("Found calibration file for sensor '{0}' : {1}.".format(
-#                             device_label, filename))
-#                         calibration_files.append(filename)
-
-#     if len(calibration_files) == 1:
-#         return calibration_files[0]
-#     elif len(calibration_files) > 1:
-#         print("Multiple calibration files found for sensor '{0}'".format(device_label))
-#         for f in calibration_files:
-#             print("  - {0}".format(f))
-#         print("Please ensure that only one calibration file exists for each sensor")
-#     else:
-#         print("No calibration file found for sensor '{0}'.".format(device_label))
-#     exit()
 
 
 # Sensor History with moving average filtering and distance, velocity
@@ -105,10 +104,7 @@ class SensorHistory(object):
     """
 
     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
+        self.history = [np.zeros(number_of_parameter, dtype=np.float64) for _ in range(history_size)]
 
     def __str__(self):
         return str(self.history)
@@ -124,35 +120,16 @@ class SensorHistory(object):
 
         """
 
-        self._previous_moving_average = self.moving_average
-        pop = self.history.pop(0)
+        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.
 
-        """
+    def moving_averages(self) -> npt.NDArray[np.floating]:
+        """Returns a list of moving averages for all sensor parameters."""
+        return np.mean(self.history, axis=0)
 
-        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))
+    def moving_average(self, sensor:int) -> np.floating:
+        """Returns the moving average for a specific sensor parameter."""
+        return np.mean([x[sensor] for x in self.history])
 
     @property
     def history_size(self):
@@ -160,8 +137,4 @@ class SensorHistory(object):
 
     @property
     def number_of_parameter(self):
-        return len(self.history[0])
-
-    @property
-    def previous_moving_average(self):
-        return self._previous_moving_average
+        return len(self.history[0])

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/sensor.py

@@ -1,6 +1,10 @@
-"""class to record force sensor data
+"""Sensor class for reading data from NI devices and converting to force data.
 
-See COPYING file distributed along with the pyForceDAQ copyright and license terms.
+Per default the NIDAQMX library is installed and access the NI instruments data.
+If the PyDAQMX library is installed, this library is used instead.
+
+For conversion to force data, the ATI dll will be used (use_aiftt=True, DEFAULT). Alternatively, you
+might use your own complied dll and pyforceDAQ own interface to the DLL (use_aiftt=False)
 """
 
 __author__ = "Oliver Lindemann"
@@ -22,7 +26,7 @@ class Sensor(object):
 
     def __init__(self, s_settings: SensorSettings,
                  daq_type: int,
-                 use_aiftt: bool):
+                 use_aiftt: bool=True):
         """DOC"""
 
         assert isinstance(s_settings, SensorSettings)
@@ -72,7 +76,7 @@ class Sensor(object):
         """sets the bias"""
 
         if np.shape(data)[1] != len(Sensor.SENSOR_CHANNELS):
-            raise ValueError(f"biasdata should have the shape (x, n_sensor_channels)")
+            raise ValueError("Bias data should have the shape (x, n_sensor_channels)")
 
         if self._calib_converter is not None:
             self._calib_converter.bias(np.mean(data, axis=0))

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/sensor_process.py

@@ -26,7 +26,7 @@ class SensorProcess(Process):
         recording_settings: RecordingSettings,
         file_writer_queue: Optional[Queue],
         daq_type: int,
-        use_aiftt: bool
+        use_aiftt: bool = True
     ):
         """ForceSensorProcess
 
@@ -62,7 +62,8 @@ class SensorProcess(Process):
         self._np_dat = np.frombuffer(
             self._dat.get_obj(), dtype=np.float64
         )  # numpy view
-        self._sample_cnt = Value(ct.c_int64, 0)
+        self._saved_sample_cnt = Value(ct.c_int64, 0)
+        self._total_sample_cnt = Value(ct.c_int64, 0)
         self.flag_sensor_bias_is_determined = Event()
         self._flag_quit_request = Event()
         self.__flag_is_saving = Event()
@@ -107,7 +108,10 @@ class SensorProcess(Process):
         return self._np_dat[3:6]
 
     def get_saved_sample_cnt(self) -> int:
-        return self._sample_cnt.value
+        return self._saved_sample_cnt.value
+
+    def get_total_sample_cnt(self) -> int:
+        return self._total_sample_cnt.value
 
     def determine_bias(self):
         self.flag_sensor_bias_is_determined.clear()
@@ -144,6 +148,7 @@ class SensorProcess(Process):
         if self.recording_settings.lsl_stream:
             lsl_data_steam.init(
                 name=f"Force_{sensor.device_label}",
+                content_type="force",
                 n_channels=sum(stream_forces),
                 stream_id=f"RF_{sensor.device_label}",
                 freq=self.sensor_settings.rate,
@@ -155,6 +160,7 @@ class SensorProcess(Process):
             if n_hardware_trigger > 0:
                 lsl_hardware_trigger_stream.init(
                     name=f"Trigger_{sensor.device_label}",
+                    content_type="Marker",
                     n_channels=n_hardware_trigger,
                     stream_id=f"Tr_{sensor.device_label}",
                     channel_format=cf_float32,
@@ -192,31 +198,28 @@ class SensorProcess(Process):
                 continue
 
             ## LSL
-            if lsl_data_steam.is_init:
-                # stream only select forces
-                lsl_data_steam.outlet.push_sample(d.forces[stream_forces])  # type: ignore
+            lsl_data_steam.push_sample(d.forces[stream_forces])
             if lsl_hardware_trigger_stream.is_init:
                 tr = d.trigger[stream_trigger]
                 if any(tr):  # only stream if at least one trigger is active
                     lsl_hardware_trigger_stream.outlet.push_sample(tr)  # type: ignore
 
             # write to shared memory and file writer queue
+            self._total_sample_cnt.value += 1 # type: ignore
             self._dat[:] = d.forces
             fifo.append(d.forces) # for bias determination
 
             if self.is_saving() and self._file_writer_queue is not None:
                 self._file_writer_queue.put(d)
-                self._sample_cnt.value += 1  # type: ignore
+                self._saved_sample_cnt.value += 1  # type: ignore
 
             if not self.flag_sensor_bias_is_determined.is_set():
                 # new baseline requested
                 sensor.set_bias(np.array(fifo))
                 self.flag_sensor_bias_is_determined.set()
-                # FIXME determine bias marker event?
 
         # stop process
         self.pause_saving()
         sensor.daq.stop_data_acquisition()
         logging.info("Sensor quit, %s", sensor.device_label)
 
-# FIXME check trigger processing and UDP connections

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/types.py

@@ -10,8 +10,6 @@ from .misc import MinMaxDetector as _MinMaxDetector
 
 # tag in data output
 TAG_COMMENTS = "#"
-TAG_DAQEVENT = TAG_COMMENTS + "T"
-TAG_UDPDATA = TAG_COMMENTS + "UDP"
 
 CTYPE_FORCES = ct.c_double * 600
 CTYPE_TRIGGER = ct.c_double * 2
@@ -181,6 +179,13 @@ class ForceSensorData(TimedData):
         self.forces = struct.forces
         self.trigger = struct.trigger
 
+    @classmethod
+    def force_id(cls, force_label) -> float | None:
+        """returns the id of the force parameter with the given label or None if not found"""
+        try:
+            return cls.forces_names.index(force_label)
+        except ValueError:
+            return None
 
 class UDPData(TimedData):
     """The UDP data class, used to store UDP DATA with timestamps"""
@@ -212,28 +217,6 @@ def bytes_startswith(a, b):
     return a[: len(b)] == b
 
 
-class DAQEvents(TimedData):
-    """The DAQEvents data class, used to store trigger
-
-    See Also
-    --------
-    DataRecorder.set_daq_event()
-
-    """
-
-    def __init__(self, time: float | None, code: str | int | float):
-        """Create a DAQEvents object
-
-        Parameters
-        ----------
-        time : float
-        code : numerical or string
-
-        """
-        super().__init__(time)
-        self.code = code
-
-
 class Thresholds(object):
     def __init__(self, thresholds, n_channels=1):
         """Thresholds for a one or multiple channels of data"""
@@ -268,7 +251,7 @@ class Thresholds(object):
     def thresholds(self):
         return self._thresholds
 
-    def get_level(self, value):
+    def get_level(self, value) -> int:
         """return [int]
         int: the level of current sensor value depending of thresholds (array)
 
@@ -298,20 +281,14 @@ class Thresholds(object):
         self._minmax[channel] = None
         return self._prev_level[channel]
 
-    def get_level_change(self, value, channel=0):
+    def get_level_change(self, value, channel=0) -> tuple[bool, int] | tuple[None, None]:
         """return tuple with level_change (boolean) and current level (int)
-        if level change detection is switch on
-
-        Note: after detected level change detection is switched off!
         """
 
-        if self._prev_level[channel] is None:
-            return None, None
-
         current = self.get_level(value)
         changed = current != self._prev_level[channel]
         if changed:
-            self._prev_level[channel] = None
+            self._prev_level[channel] = current
         return changed, current
 
     def __str__(self):
@@ -333,7 +310,7 @@ class Thresholds(object):
         self._prev_level[channel] = None
         return lv
 
-    def get_response_minmax(self, value, channel=0):
+    def get_response_minmax(self, value, channel=0) -> tuple[int, int] | tuple[None, None]:
         """checks for response minimum and maximum if set_response_minmax_detection is switch on
         With this function you add a sample and check if the response can be classified. If so,
         it returns a tuple with the minimum and maximum response level during the response period
@@ -346,7 +323,7 @@ class Thresholds(object):
         """
 
         if self._minmax[channel] is None:
-            return None
+            return None, None
 
         rtn = self._minmax[channel].process(self.get_level(value))
         if rtn is not None:

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/udp_connection.py

@@ -5,36 +5,15 @@ __version__ = "0.5"
 
 import atexit
 import logging
-import os
 import socket
 from multiprocessing import Event, Process, Queue
-from subprocess import check_output
 
 from .clock import local_clock, wait_ms
+from .misc import get_lan_ip
 from .process_priority_manager import get_priority
 from .types import UDPData
 
 
-def get_lan_ip():
-    if os.name == "nt":
-        # Windows
-        return socket.gethostbyname(socket.gethostname())
-    else:
-        # Linux and macOS
-        try:
-            # Try Linux command first
-            rtn = check_output(["hostname", "-I"]).decode().strip()
-            return rtn.split()[0] if rtn else None
-        except:
-            try:
-                # Fallback to macOS command
-                rtn = check_output(["ipconfig", "getifaddr", "en0"]).decode().strip()
-                return rtn if rtn else None
-            except:
-                # Fallback to socket method if both commands fail
-                return socket.gethostbyname(socket.gethostname())
-
-
 class UDPConnection(object):
     # DOC document the usage "connecting" "unconnecting"
     COMMAND_CHAR = b"$"
@@ -196,7 +175,7 @@ class UDPConnectionProcess(Process):
         # Server that prints each input and echos it to the client
         # that is currently connected
 
-        from udp_connection import UDPConnectionProcess, Queue
+        from pyforcedaq._lib.udp_connection import UDPConnectionProcess, Queue
 
         receive_queue = Queue()
         udp_p = UDPConnectionProcess(receive_queue=receive_queue)

pyforcedaq-2.0.7/src/pyforcedaq/gui/__init__.py

@@ -0,0 +1,7 @@
+
+print("\nStarting pyforceDAQ GUI...")
+from .._lib import settings  # # read settings
+from ._run import (
+    run,  # for running with options from Python script
+    run_settings_file,
+)

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/gui/_gui_status.py

@@ -4,6 +4,7 @@ __author__ = "Oliver Lindemann"
 from time import sleep
 from typing import List, Tuple
 
+import numpy as np
 from expyriment import io, misc
 
 from .._lib.data_recorder import DataRecorder
@@ -56,7 +57,9 @@ class GUIStatus(object):
 
         self.sensor_processes = recorder.force_sensor_processes
         self.n_sensors = len(self.sensor_processes)
-        self.history = []
+        self.force_id_level_detect = ForceSensorData.force_id(gui_settings.level_detection_parameter)
+
+        self.history: List[SensorHistory] = []
         for _ in range(self.n_sensors):
             self.history.append(
                 SensorHistory(
@@ -69,9 +72,7 @@ class GUIStatus(object):
         self.clear_screen = True
         self.thresholds = None
         self.set_marker = False
-        self.last_udp_data = None
         self._last_processed_smpl = [0] * self.n_sensors
-        self._last_thresholds = None
         self._clock = misc.Clock()
 
         self.sensor_info_str = ""
@@ -159,7 +160,7 @@ class GUIStatus(object):
         """returns list of sensors with new samples"""
         rtn = []
         for i, cnt in enumerate(
-            map(SensorProcess.get_saved_sample_cnt, self.sensor_processes)
+            map(SensorProcess.get_total_sample_cnt, self.sensor_processes)
         ):
             if self._last_processed_smpl[i] < cnt:
                 # new sample
@@ -167,14 +168,6 @@ class GUIStatus(object):
                 rtn.append(i)
         return rtn
 
-    def check_thresholds_changed(self):
-        """returns only true if not changed between calls"""
-        if self.thresholds != self._last_thresholds:
-            # new sample
-            self._last_thresholds = self.thresholds
-            return True
-        return False
-
     def process_key(self, key):
         if key == misc.constants.K_q or key == misc.constants.K_ESCAPE:
             self.quit_recording = True
@@ -229,19 +222,12 @@ class GUIStatus(object):
             else:
                 self.thresholds = None
 
-    def process_udp_event(self, udp_event):
-        """remote control"""
-        self.set_marker = True
-        self.last_udp_data = udp_event.byte_string
-
-    def update_history(self, sensor):
+    def update_history(self, sensor:int):
         self.history[sensor].update(self.sensor_processes[sensor].get_Fxyz())
 
-    def level_detection_parameter_average(self, sensor):
+    def get_average_level_detection_parameter(self, sensor:int) -> np.floating | None:
         """just a short cut"""
-        if sensor < self.n_sensors:
-            return self.history[sensor].moving_average[
-                self.gs.level_detection_parameter
-            ]
+        if sensor < self.n_sensors and isinstance(self.force_id_level_detect, int):
+            return self.history[sensor].moving_average(self.force_id_level_detect)
         else:
             return None

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/gui/_run.py

@@ -7,7 +7,6 @@ __author__ = "Oliver Lindemann"
 import logging
 import os
 from pathlib import Path
-from pickle import dumps
 from time import sleep
 from typing import List
 
@@ -20,25 +19,21 @@ from .._lib.clock import wait_ms
 from .._lib.data_recorder import DataRecorder
 from .._lib.sensor_process import SensorProcess
 from .._lib.settings import AppSettings, GUISettings, SensorSettings
+from .._lib.types import ForceSensorData
 from ..constants import DEFAULT_OUTPUT_FILENAME
 from ._gui_status import GUIStatus
 from ._layout import colours, get_pygame_rect, logo_text_line, make_text_line
 from ._level_indicator import level_indicator
 from ._plotter import PlotterThread
 
-# eedback
-COMMAND_STR = b"$"
-RESPONSE_MINMAX = COMMAND_STR + b"xRM1"
-RESPONSE_MINMAX2 = COMMAND_STR + b"xRM2"
-CHANGED_LEVEL = COMMAND_STR + b"xCL1"
-CHANGED_LEVEL2 = COMMAND_STR + b"xCL2"
+# Feedback
+
+RESPONSE_MINMAX = "RM"
+RESPONSE_MINMAX2 = "RM2"
+CHANGED_LEVEL = "CL"
+CHANGED_LEVEL2 = "CL2"
 
 def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[str]):
-    """udp command:
-    "start", "pause", "stop"
-    "thresholds = [x,...]" : start level detection for Fz parameter and set threshold
-    "thresholds stop" : stop level detection
-    """
 
     indicator_grid = 70  # distance between indicator center
     plotter_width = 900
@@ -52,8 +47,10 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
     exp.keyboard.clear()
 
     last_recording_status = None
-
+    last_thresholds = None
+    recorder.lsl_events_stream.push_sample(["Recording started, " + forceDAQVersion])
     s.background.stimulus().present()
+
     while not s.quit_recording:  ######## process loop
         if s.pause_recording:
             wait_ms(100)
@@ -61,35 +58,32 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
         ################################ process keyboard
         s.process_key(exp.keyboard.check(check_for_control_keys=False))
 
-        ##############################  process udp
-        udp = recorder.process_and_write_udp_events()
-        while len(udp) > 0:
-            s.process_udp_event(udp.pop(0))
-
         ########################### process new samples
         for x in s.check_new_samples():
             s.update_history(sensor=x)
 
-            if s.thresholds is not None:
+            if s.thresholds is not None and isinstance(s.force_id_level_detect, int):
                 # level change detection
                 level_change, tmp = s.thresholds.get_level_change(
-                    s.history[x].moving_average[gs.level_detection_parameter], channel=x
+                    s.history[x].moving_average(s.force_id_level_detect), channel=x
                 )
                 if level_change:
                     if x == 1:
-                        recorder.udp.send_queue.put(CHANGED_LEVEL2 + dumps(tmp))  # type: ignore
-                    else:
-                        recorder.udp.send_queue.put(CHANGED_LEVEL + dumps(tmp))  # type: ignore
-
-                # minmax detection
-                tmp = s.thresholds.get_response_minmax(
-                    s.history[x].moving_average[gs.level_detection_parameter], channel=x
-                )
-                if tmp is not None:
-                    if x == 1:
-                        recorder.udp.send_queue.put(RESPONSE_MINMAX2 + dumps(tmp))  # type: ignore
+                        resp = f"{CHANGED_LEVEL}-{tmp}"
                     else:
-                        recorder.udp.send_queue.put(RESPONSE_MINMAX + dumps(tmp))  # type: ignore
+                        resp = f"{CHANGED_LEVEL2}-{tmp}"
+                    recorder.lsl_events_stream.push_sample([resp])
+
+                ## minmax detection FIXME needs to call first  "set_response_minmax_detection"
+                # tmp = s.thresholds.get_response_minmax(
+                #     s.history[x].moving_average(s.force_id_level_detect), channel=x
+                # )
+                # if tmp[0] is not None:
+                #     if x == 1:
+                #         resp = f"{RESPONSE_MINMAX}-{tmp}"
+                #     else:
+                #         resp = f"{RESPONSE_MINMAX2}-{tmp}"
+                #     recorder.lsl_events_stream.push_sample([resp])
 
         ######################## show pause or recording screen
         if s.pause_recording != last_recording_status:
@@ -106,10 +100,12 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
         if s.check_refresh_required():  # do not give priority to visual output
             update_rects = []
 
-            if s.check_thresholds_changed():
+            if s.thresholds != last_thresholds:
+                # thresholds have changed
                 _draw_plotter_thread_thresholds(
                     plotter_thread, s.thresholds, s.scaling_plotter
                 )
+                last_thresholds = s.thresholds
 
             if s.plot_indicator:
                 ############################################  plot_indicator
@@ -132,7 +128,7 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
                         + 0.5 * indicator_grid
                     )
 
-                    if cnt == gs.level_detection_parameter:
+                    if cnt == s.force_id_level_detect:
                         thr = s.thresholds
                     else:
                         thr = None
@@ -236,11 +232,11 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
                     tmp = np.array(
                         list(
                             map(
-                                lambda x: s.history[x[0]].moving_average[x[1]],
+                                lambda x: s.history[x[0]].moving_average(x[1]),
                                 s.plot_data_plotter,
                             )
                         ),
-                        dtype=float,
+                        dtype=np.float64,
                     )
                 else:
                     tmp = np.array(
@@ -250,7 +246,7 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
                                 s.plot_data_plotter,
                             )
                         ),
-                        dtype=float,
+                        dtype=np.float64,
                     )
 
                 if s.thresholds is not None:
@@ -316,33 +312,31 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
             txt.present(update=False, clear=False)
             update_rects.append(get_pygame_rect(txt, exp.screen.size))
 
-            #FIXME Threshold levels down work
-
             # Sensor info
             pos = (200, 250)
             tmp = stimuli.Canvas(
-                position=pos, size=(400, 50), colour=misc.constants.C_BLACK
+                position=pos, size=(600, 50), colour=misc.constants.C_BLACK
             )
             tmp.present(update=False, clear=False)
             update_rects.append(get_pygame_rect(tmp, exp.screen.size))
             if s.thresholds is not None:
                 if s.n_sensors > 1:
                     tmp = [
-                        s.thresholds.get_level(s.level_detection_parameter_average(0)),
-                        s.thresholds.get_level(s.level_detection_parameter_average(1)),
+                        s.thresholds.get_level(s.get_average_level_detection_parameter(0)),
+                        s.thresholds.get_level(s.get_average_level_detection_parameter(1)),
                     ]
                 else:
-                    tmp = s.thresholds.get_level(s.level_detection_parameter_average(0))
+                    tmp = s.thresholds.get_level(s.get_average_level_detection_parameter(0))
+
 
                 txt = stimuli.TextBox(
                     position=pos,
-                    size=(400, 50),
+                    size=(600, 50),
                     text_size=15,
                     text="T: {0} L: {1}".format(s.thresholds, tmp),
                     text_colour=misc.constants.C_YELLOW,
                     text_justification=0,
                 )
-
                 txt.present(update=False, clear=False)
 
             pos = (400, 250)
@@ -362,30 +356,13 @@ def _main_loop(exp, recorder: DataRecorder, gs: GUISettings, info_strings: List[
                 )
                 txt.present(update=False, clear=False)
 
-            # last_udp input
-            if s.last_udp_data is not None:
-                pos = (420, 250)
-                stimuli.Canvas(
-                    position=pos, size=(200, 30), colour=misc.constants.C_BLACK
-                ).present(update=False, clear=False)
-                txt = stimuli.TextBox(
-                    position=pos,
-                    size=(200, 30),
-                    # background_colour=(30,30,30),
-                    text_size=15,
-                    text="UDP:" + str(s.last_udp_data),
-                    text_colour=misc.constants.C_YELLOW,
-                    text_justification=0,
-                )
-                txt.present(update=False, clear=False)
-                update_rects.append(get_pygame_rect(txt, exp.screen.size))
-
             pygame.display.update(update_rects)
             # end plotting screen
 
         ##### end main  loop
 
     recorder.pause_saving()
+    recorder.lsl_events_stream.push_sample(["Recording stopped"])
     s.background.stimulus("Quitting").present()
     if plotter_thread is not None:
         plotter_thread.join()
@@ -435,15 +412,13 @@ def run(settings: AppSettings):
     pygame.display.set_caption(f"pyforceDAQ {forceDAQVersion}")
 
     icon_path = os.path.join(os.path.dirname(__file__), "rf_icon.png")
-    print(f"Loading icon from {icon_path}")
     pygame.display.set_icon(pygame.image.load(icon_path))
 
     logo_text_line("Initializing Force Recording").present()
     show_logo_time = 0.5
     recorder = DataRecorder(
         recording_settings=rs,
-        force_sensor_settings=sensor_settings,
-        poll_udp_connection=False,  # FIXME remove UDP polling from recorder and put it in main loop
+        force_sensor_settings=sensor_settings
     )
 
     if rs.save_data:

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/launcher.py

@@ -6,9 +6,8 @@ from typing import List
 import PySimpleGUI as _sg
 
 from . import __version__, constants
-from ._lib.misc import list_settings_files
+from ._lib.misc import get_lan_ip, list_settings_files
 from ._lib.settings import AppSettings
-from ._lib.udp_connection import UDPConnection
 
 
 def _check_sensor_calibration_settings(
@@ -64,7 +63,7 @@ def _windows_run(settings: AppSettings):
         info_settings.append([_sg.Text(f"- {labels}: {cal}", text_color=col)])
 
     info = [[_sg.Text(f"version: {__version__}")]]
-    info.append([_sg.Text(f"IP address: {UDPConnection.MY_IP}")])
+    info.append([_sg.Text(f"IP address: {get_lan_ip()}")])
 
     if constants.DAQ_TYPE == constants.MOCK_SENSOR:
         info.append([_sg.Text("!!!  USING MOCK SENSORS  !!!", text_color="red")])

pyforcedaq-2.0.6/src/pyforcedaq/gui/__init__.py

@@ -1,5 +0,0 @@
-
-print("\nStarting pyforceDAQ GUI...")
-from .._lib import settings  # # read settings
-from ._run import run  # for running with options from Python script
-from ._run import run_settings_file

{pyforcedaq-2.0.6 → pyforcedaq-2.0.7}/src/pyforcedaq/_lib/settings.py

@@ -152,6 +152,7 @@ class RecordingSettings(ABCSettings):
 
 @dataclass
 class GUISettings(ABCSettings):
+
     level_detection_parameter: str = "Fz"
     window_font: str = "freemono"
     moving_average_size: int = 5
@@ -174,7 +175,6 @@ class GUISettings(ABCSettings):
         default_factory=lambda: [(0, 2), (1, 2)]
     )
 
-
 class AppSettings(object):
     def __init__(self, filename: str | Path):
         # defaults