pyForceDAQ 2.0.1.dev0__tar.gz → 2.0.1.dev2__tar.gz

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.1.dev0
+Version: 2.0.1.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>

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyForceDAQ"
-version = "2.0.1-dev0"
+version = "2.0.1-dev2"
 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.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/__init__.py

@@ -7,7 +7,7 @@ launch the GUI force from your Python program:
 ``
     from pyforcedaq import gui
 
-    gui.run_with_options(remote_control=False,
+    gui.run(remote_control=False,
               ask_filename=True,
                calibration_file="FT_sensor1.cal")
 ``

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/__main__.py

@@ -34,9 +34,9 @@ def cli():
         from .gui import launcher
         return launcher.run()
     else:
-        gui.run(args.SETTINGS_FILE)
+        gui.run_settings(args.SETTINGS_FILE)
 
 
 
 if __name__ == "__main__": # required because of threading
-    cli() # gui.run(), gui.run_with_options()
+    cli()

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/_lib/misc.py

@@ -39,20 +39,31 @@ class MinMaxDetector(object):
         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))
-
+# def find_calibration_file(calibration_folder: str, sensor_name: str,
+#                           calibration_suffix=".cal") -> str:
+
+#     needle = 'Serial="{0}"'.format(sensor_name)
+#     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(
+#                             sensor_name, 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(sensor_name))
+#         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(sensor_name))
+#     exit()
 
 #Sensor History with moving average filtering and distance, velocity
 class SensorHistory(object):

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/_lib/types.py

@@ -1,7 +1,7 @@
 __author__ = 'Oliver Lindemann'
 
 import ctypes as ct
-from typing import List
+from typing import Iterator, List, Tuple
 
 from .misc import MinMaxDetector as _MinMaxDetector
 
@@ -13,7 +13,7 @@ TAG_UDPDATA = TAG_COMMENTS + "UDP"
 CTYPE_FORCES = ct.c_float * 600
 CTYPE_TRIGGER = ct.c_float * 2
 
-class PollingPriority(object):
+class PollingPriority(object): # TODO needed?
 
     NORMAL = 'normal'
     HIGH = 'high'
@@ -160,12 +160,13 @@ class ForceSensorData(object):
         self.force = struct.forces
         self.trigger = struct.trigger
 
-    def selected_forces(self, select: List[bool]):
-        """Return an iterator over selected force values."""
-        return (force for i, force in enumerate(self.forces) if select[i])
+    def selected_forces(self, select: List[bool]) -> List[float]:
+        """Return list of selected force values."""
+        return [force for i, force in enumerate(self.forces) if select[i]] # FIXME simplify not all force have to save in ForceClass
 
-    def selected_trigger(self, select: List[bool]):
-        return (trigger for i, trigger in enumerate(self.trigger) if select[i])
+    def selected_trigger(self, select: List[bool]) -> List[float]:
+        """Return list of selected trigger values."""
+        return [trigger for i, trigger in enumerate(self.trigger) if select[i]]
 
 
 class UDPData(object):

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/daq/__init__.py

@@ -1,5 +1,5 @@
 __author__ = "Oliver Lindemann"
-__version__ = "0.4"
+__version__ = "0.5"
 
 from .. import USE_MOCK_SENSOR
 from ._pyATIDAQ import ATI_CDLL
@@ -11,9 +11,10 @@ if USE_MOCK_SENSOR:
 else:
     #### change import here if you want to use nidaqmx instead of pydaymx ####
     try:
-        from ._daq_read_analog_pydaqmx import DAQReadAnalog
-        #from ._daq_read_analog_nidaqmx import DAQReadAnalog
-    except (ImportError, ModuleNotFoundError):
+        from ._use_pydaqmx import DAQReadAnalog
+        #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
 

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/daq/_mock_sensor.py

@@ -75,6 +75,6 @@ class DAQReadAnalog(object):
             n_new_samples = self._simulation_timer.time - self._sample_cnt
 
         self._sample_cnt += 1
-        x = self._sample_cnt / 2000
+        x = self._sample_cnt / 1000
         y = 10 + np.array((np.sin(x/2), np.cos(x/5), np.sin(x)))*10
         return np.append(y, np.array((0, 0 , 0, 0, 0))), 1

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/daq/_pyATIDAQ.py

@@ -12,8 +12,6 @@ __author__ = "Oliver Lindemann"
 from ctypes import *
 from sys import platform
 
-from .._lib.misc import find_calibration_file
-
 # ### DATA TYPES ####
 VOLTAGE_SAMPLE_TYPE = c_float * 7
 FT_SAMPLE_TYPE = c_float * 6
@@ -292,7 +290,7 @@ if __name__ == "__main__":
     #   -0.065867  0.123803 111.156731  0.039974  0.040417  0.079049
 
     #filename = raw_input("Calibration file: ")
-    filename = find_calibration_file("calibration", "FT30436")
+    filename = "calibration/FT30436.cal"
     atidaq = ATI_CDLL()
     # get calibration
     index = c_short(1)

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/force/data_recorder.py

@@ -7,8 +7,7 @@ __author__ = "Oliver Lindemann"
 import atexit
 import gzip
 import logging
-import os
-import sys
+from pathlib import Path
 from time import asctime, localtime, strftime
 
 from pyforcedaq._lib import timer
@@ -38,7 +37,7 @@ class DataRecorder(object):
     def __init__(self, force_sensor_settings:SensorSettings | list,
                  poll_udp_connection=False,
                  write_deviceid = False,
-                 polling_priority=None):
+                 polling_priority:str | None = None):
 
 
         """queue_data will be saved
@@ -82,18 +81,18 @@ class DataRecorder(object):
         self._proc_manager.add_subprocess(self.udp)
         self._proc_manager.add_subprocess(self._force_sensor_processes)
         if polling_priority is not None:
-            self._proc_manager.set_subprocess_priorities(
-                level=PollingPriority.get_priority(polling_priority),
-                disable_gc=False)
+           level = PollingPriority.NORMAL
+        else:
+            level = PollingPriority.get_priority(polling_priority)
+        self._proc_manager.set_subprocess_priorities(level=level, disable_gc=False)
 
-        logging.info("Main process priority: {}".format(
-            self._proc_manager.get_main_priority()))
+        logging.info("Main process priority: %s", self._proc_manager.get_main_priority())
         #logging.info("Subprocess priorities: {}".format(self._proc_manager.get_subprocess_priorities()))
 
         self._is_recording = False
         self._file = None
         self._daq_event = []
-        self.filename = None
+        self.filename: str | None = None
         atexit.register(self.quit)
 
 
@@ -102,7 +101,7 @@ class DataRecorder(object):
         """Property indicates whether the recording processes are alive"""
         try:
             return self._force_sensor_processes[0].is_alive()
-        except:
+        except Exception:
             return False
 
     @property
@@ -119,7 +118,7 @@ class DataRecorder(object):
         return list(map(lambda x:x.sensor_settings,
                         self._force_sensor_processes))
 
-    def quit(self):
+    def quit(self) -> list | None:
         """Stop all recording processes, close data file and quit recording
 
         Notes
@@ -145,7 +144,7 @@ class DataRecorder(object):
 
         return buffer
 
-    def process_and_write_udp_events(self):
+    def process_and_write_udp_events(self) -> list:
         """process udp events and return them"""
         buffer = []
         while True:
@@ -159,9 +158,9 @@ class DataRecorder(object):
             self._save_data(buffer)
         return buffer
 
-    def _save_data(self, data_buffer,
+    def _save_data(self, data_buffer: list,
                    recording_screen=None,
-                   float_decimal_places=4):
+                   float_decimal_places: int = 4) -> None:
         """ writes data to disk and set counters
 
         ignores UDP remote control commands
@@ -199,10 +198,10 @@ class DataRecorder(object):
                     "Writing {0} of {1} blocks".format(c//BLOCKSIZE,
                                                        buffer_len//BLOCKSIZE)).present()
 
-    def _file_write(self, str):
-        self._file.write(str.encode())
+    def _file_write(self, s: str) -> None:
+        self._file.write(s.encode())
 
-    def save_daq_event(self, code, time=None):
+    def save_daq_event(self, code, time: float | None = None) -> None:
         """Set marker code in file
 
         DAQEvent will be timestamps and occur in the data output
@@ -213,7 +212,7 @@ class DataRecorder(object):
         self._daq_event.append(DAQEvents(time = time, code = code))
 
 
-    def start_recording(self, determine_bias=False):
+    def start_recording(self, determine_bias: bool = False) -> None:
         """Start polling process and record
 
         See Also
@@ -233,7 +232,7 @@ class DataRecorder(object):
         list(map(lambda x:x.start_polling(), self._force_sensor_processes))
         self._is_recording = True
 
-    def pause_recording(self, recording_screen=None):
+    def pause_recording(self, recording_screen=None) -> list:
         """Pauses all polling processes and process data
 
         returns
@@ -268,7 +267,7 @@ class DataRecorder(object):
         self._daq_event = []
         return data
 
-    def determine_biases(self, n_samples):
+    def determine_biases(self, n_samples: int) -> None:
         """Record n data samples (n_samples) to determine bias.
         Afterwards recording is in pause mode
 
@@ -289,12 +288,12 @@ class DataRecorder(object):
         for x in self._force_sensor_processes:
             x.event_bias_is_available.wait()
 
-    def open_data_file(self, filename,
-                       subdirectory="data",
-                       time_stamp_filename=False,
-                       varnames = True,
-                       comment_line="",
-                       zipped=False):
+    def open_data_file(self, filename: str,
+                       subdirectory: str = "data",
+                       time_stamp_filename: bool = False,
+                       varnames: bool = True,
+                       comment_line: str = "",
+                       zipped: bool = False) -> Path:
         """Create a data file
 
         Only if data file has been opened, data will be saved!
@@ -322,11 +321,8 @@ class DataRecorder(object):
                 full path the actually used file (incl. timestamp)
 
         """
-
-        base_dir = os.path.split(sys.argv[0])[0]
-        data_dir = os.path.join(base_dir, subdirectory)
-        if not os.path.isdir(data_dir):
-            os.mkdir(data_dir)
+        data_dir = Path.cwd() / subdirectory
+        data_dir.mkdir(exist_ok=True)
         self.close_data_file()
 
         if filename is None or len(filename) == 0:
@@ -352,8 +348,8 @@ class DataRecorder(object):
             else:
                 self.filename = flname + suffix
 
-            full_path_file = os.path.join(data_dir, self.filename)
-            if os.path.isfile(full_path_file):
+            full_path_file = data_dir / self.filename
+            if full_path_file.is_file():
                 # print "data file already exists, adding counter"
                 cnt += 1
             else:
@@ -388,7 +384,7 @@ class DataRecorder(object):
 
         return full_path_file
 
-    def close_data_file(self):
+    def close_data_file(self) -> None:
         """Close the data file
 
         Afterwards data will not be saved anymore.

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/force/sensor.py

@@ -7,11 +7,11 @@ __author__ = 'Oliver Lindemann'
 
 import ctypes as ct
 from copy import copy
+from pathlib import Path
+from typing import List, Tuple
 
 import numpy as np
 
-#from .._lib import lsl
-from .._lib.misc import find_calibration_file
 from .._lib.timer import Timer, app_clock
 from .._lib.types import ForceSensorData
 from ..daq import ATI_CDLL, DAQConfiguration, DAQReadAnalog
@@ -22,15 +22,15 @@ class SensorSettings(DAQConfiguration):
     def __init__(self,
                  device_id:int,
                  sensor_name:str,
-                 calibration_folder:str,
+                 calibration_file:str | Path,
                  channels="ai0:7",
                  device_name_prefix = "Dev",
                  rate:int=1000,
-                 minVal=-10,
-                 maxVal=10,
-                 reverse_parameter_names=(),
+                 minVal:float=-10,
+                 maxVal:float=10,
+                 reverse_parameter_names: str | Tuple[str] | List[str] | None = None,
                  convert_to_FT:bool=True,
-                 has_lsl_stream:bool=False,
+                 lsl_stream:bool=False,
                  write_Fx:bool=True,
                  write_Fy:bool=True,
                  write_Fz:bool=True,
@@ -53,7 +53,7 @@ class SensorSettings(DAQConfiguration):
         self.device_id = device_id
         self.sensor_name = sensor_name
         self.convert_to_FT = convert_to_FT
-        self.has_lsl_stream = has_lsl_stream
+        self.lsl_stream = lsl_stream
         self.write_Fx = write_Fx
         self.write_Fy = write_Fy
         self.write_Fz = write_Fz
@@ -62,22 +62,17 @@ class SensorSettings(DAQConfiguration):
         self.write_Tz = write_Tz
         self.write_trigger1 = write_trigger1
         self.write_trigger2 = write_trigger2
-
-        if self.convert_to_FT:
-            self.calibration_file = find_calibration_file(
-                                        calibration_folder=calibration_folder,
-                                        sensor_name=sensor_name)
-        else:
-            self.calibration_file = None
+        self.calibration_file = calibration_file
 
         self.reverse_parameters = []
-        if not isinstance(reverse_parameter_names, (tuple, list)):
-            reverse_parameter_names = [reverse_parameter_names]
-        for para in reverse_parameter_names:
-            try:
-                self.reverse_parameters.append(ForceSensorData.forces_names.index(para))
-            except Exception:
-                pass
+        if reverse_parameter_names is not None:
+            if isinstance(reverse_parameter_names, str):
+                reverse_parameter_names = [reverse_parameter_names]
+            for para in reverse_parameter_names:
+                try:
+                    self.reverse_parameters.append(ForceSensorData.forces_names.index(para))
+                except Exception:
+                    pass
 
     def array_write_forces(self):
         return [self.write_Fx, self.write_Fy, self.write_Fz, self.write_Tx, self.write_Ty, self.write_Tz]
@@ -105,7 +100,7 @@ class Sensor(DAQReadAnalog):
         self.name = settings.sensor_name
         self.convert_to_FT = settings.convert_to_FT
         self.timer = Timer(sync_timer=app_clock) # own timer, because this class is used in own process
-        if self.DAQ_TYPE == "mock":
+        if self.DAQ_TYPE == "mock_sensor":
             self._atidaq = None
             self.convert_to_FT = False
         else:

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/force/sensor_process.py

@@ -157,19 +157,21 @@ class SensorProcess(Process):
         ## create init LSL
         lsl_data_steam = None
         lsl_hardware_trigger_stream = None
-        if self.sensor_settings.has_lsl_stream:
+        if self.sensor_settings.lsl_stream:
             lsl_data_steam = lsl.init(
-                    name=f"Force {self.sensor_settings.device_name}",
+                    name=f"Force_{self.sensor_settings.device_name}",
                     n_channels=sum(stream_forces),
                     stream_id=f"RF_{self.sensor_settings.device_name}",
                     freq=self.sensor_settings.rate,
+                    channel_format= lsl.cf_float32,
                     metadata={"sensor_name": self.sensor_settings.sensor_name})
             n_hardware_trigger = sum(stream_trigger)
             if n_hardware_trigger > 0:
                 lsl_hardware_trigger_stream = lsl.init(
-                    name=f"Trigger {self.sensor_settings.device_name}",
+                    name=f"Trigger_{self.sensor_settings.device_name}",
                     n_channels=n_hardware_trigger,
                     stream_id=f"Tr_{self.sensor_settings.device_name}",
+                    channel_format=lsl.cf_float32,
                     freq=self.sensor_settings.rate)
 
 
@@ -189,9 +191,12 @@ class SensorProcess(Process):
                 d = sensor.poll_data()
                 ## LSL
                 if lsl_data_steam is not None:
-                    lsl_data_steam.push_sample(list(d.selected_forces(stream_forces))) # steam only select forces
+                    lsl_data_steam.push_sample(d.selected_forces(stream_forces)) # steam only select forces
+
                 if lsl_hardware_trigger_stream is not None:
-                    lsl_hardware_trigger_stream.push_sample(list(d.selected_trigger(stream_trigger))) # stream only triggers
+                    tr = d.selected_trigger(stream_trigger)
+                    if any(tr): # only stream if at least one trigger is active
+                        lsl_hardware_trigger_stream.push_sample(tr)
 
                 ptp.update(d.time) # needed? TODO
                 self._last_Fx.value, self._last_Fy.value, self._last_Fz.value, \

pyforcedaq-2.0.1.dev2/src/pyforcedaq/gui/__init__.py

@@ -0,0 +1,6 @@
+from ._run import (
+    run,  # for running with options from Python script
+    run_settings,
+)
+from ._settings import settings  ## read settings
+

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/gui/_run.py

@@ -5,7 +5,9 @@ See COPYING file distributed along with the pyForceDAQ copyright and license ter
 __author__ = "Oliver Lindemann"
 
 import logging
+from os import path
 from pickle import dumps
+from typing import List
 
 import numpy as np
 import pygame
@@ -342,16 +344,16 @@ def _main_loop(exp, recorder, remote_control=False):
         plotter_thread.join()
     recorder.pause_recording(s.background)
 
-def run(settings_file: str | None = None):
+def run_settings(settings_file: str | None = None):
 
     if settings_file is not None and len(settings_file) > 0:
         # load different settings file if specified
         settings.load(settings_file)
 
-    return run_with_options(remote_control = settings.recording.remote_control,
+    return run(remote_control = settings.recording.remote_control,
                         ask_filename = settings.recording.ask_filename,
                         device_ids = settings.recording.device_ids,
-                        sensor_names = settings.recording.sensor_names,
+                        calibration_files = settings.recording.calibration_files,
                         calibration_folder = settings.recording.calibration_folder,
                         device_name_prefix = settings.recording.device_name_prefix,
                         write_Fx = settings.recording.write_Fx,
@@ -365,28 +367,28 @@ def run(settings_file: str | None = None):
                         zip_data=settings.recording.zip_data,
                         reverse_scaling = settings.recording.reverse_scaling,
                         convert_to_forces=settings.recording.convert_to_forces,
-                        has_lsl_stream=settings.recording.has_lsl_stream,
+                        lsl_stream=settings.recording.lsl_stream,
                         polling_priority=settings.recording.priority)
 
-def run_with_options(remote_control,
+def run(remote_control,
                      ask_filename,
-                     device_ids,
-                     sensor_names,
-                     calibration_folder,
-                     device_name_prefix="Dev",
-                     write_Fx = True,
-                     write_Fy = True,
-                     write_Fz = True,
-                     write_Tx = False,
-                     write_Ty = False,
-                     write_Tz = False,
-                     write_trigger1 = True,
-                     write_trigger2 = False,
-                     zip_data=False,
-                     reverse_scaling = None,
-                     convert_to_forces = True,
-                     has_lsl_stream = False,
-                     polling_priority = None):
+                     device_ids : int | List[int],
+                     calibration_files : str | List[str],
+                     calibration_folder: str,
+                     device_name_prefix: str="Dev",
+                     write_Fx: bool = True,
+                     write_Fy: bool = True,
+                     write_Fz: bool = True,
+                     write_Tx: bool = False,
+                     write_Ty: bool = False,
+                     write_Tz: bool = False,
+                     write_trigger1 : bool = True,
+                     write_trigger2: bool = False,
+                     zip_data: bool = False,
+                     reverse_scaling: dict | None = None,
+                     convert_to_forces: bool = True,
+                     lsl_stream: bool = False,
+                     polling_priority: str | None = None):
 
     """start gui
     remote_control should be None (ask) or True or False
@@ -401,31 +403,34 @@ def run_with_options(remote_control,
     """
     #
 
-    logging.info("New Recording with forceDAQ {}".format(forceDAQVersion))
-    logging.info("Sensors {}".format(sensor_names))
-    logging.info("Settings " + settings.recording_as_json())
+    logging.info("New Recording with forceDAQ %s", forceDAQVersion)
+    logging.info("Sensors %s", calibration_files)
+    logging.info("Settings %s", settings.recording_as_json())
 
 
     if not isinstance(device_ids, (list, tuple)):
         device_ids = [device_ids]
-    if not isinstance(sensor_names, (list, tuple)):
-        sensor_names = [sensor_names]
+    if not isinstance(calibration_files, (list, tuple)):
+        calibration_files = [calibration_files]
 
     sensors = []
-    for d_id, sn in zip(device_ids, sensor_names):
-        try:
-            reverse_parameter_names = reverse_scaling[str(d_id)]
-        except:
+    for d_id, cal_file in zip(device_ids, calibration_files):
+        if reverse_scaling is None:
             reverse_parameter_names = []
+        else:
+            try:
+                reverse_parameter_names = reverse_scaling[str(d_id)]
+            except KeyError:
+                reverse_parameter_names = []
 
         ss = SensorSettings(device_id = d_id,
                     device_name_prefix=device_name_prefix,
-                    sensor_name = sn,
-                    calibration_folder=calibration_folder,
+                    sensor_name = cal_file.split(".")[0],
+                    calibration_file=path.join(calibration_folder, cal_file),
                     reverse_parameter_names=reverse_parameter_names,
                     rate = settings.gui.sampling_rate,
                     convert_to_FT=convert_to_forces,
-                    has_lsl_stream=has_lsl_stream,
+                    lsl_stream=lsl_stream,
                     write_Fx = write_Fx,
                     write_Fy = write_Fy,
                     write_Fz = write_Fz,
@@ -436,11 +441,8 @@ def run_with_options(remote_control,
                     write_trigger2= write_trigger2)
         sensors.append(ss)
 
-
-
     # expyriment
-    control.defaults.initialize_delay = 0
-    control.defaults.pause_key = None
+    control.defaults.initialise_delay = 0
     control.defaults.window_mode = True
     control.defaults.window_size = (1000, 700)
     control.defaults.fast_quit = True

pyforcedaq-2.0.1.dev2/src/pyforcedaq/gui/_settings.py

@@ -0,0 +1,101 @@
+import json
+import os
+from dataclasses import dataclass, field
+from typing import List
+
+import tomlkit
+from icecream import ic
+
+
+@dataclass
+class _GUISettings:
+    sampling_rate: int = 1000
+    level_detection_parameter: str = "Fz"
+    window_font: str = "freemono"
+    moving_average_size: int = 5
+    screen_refresh_interval_indicator: int = 300
+    gui_screen_refresh_interval_plotter: int = 50
+    data_min_max: list = field(default_factory=lambda: [-5, 30])
+    plotter_pixel_min_max: list = field(default_factory=lambda: [-250, 250])
+    indicator_pixel_min_max: list = field(default_factory=lambda: [-150, 150])
+    plot_axis: bool = False
+    plot_data_indicator_for_single_sensor: list = field(
+        default_factory=lambda: [(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5)])
+    plot_data_plotter_for_single_sensor: list = field(
+        default_factory=lambda: [(0, 0), (0, 1), (0, 2)])
+    plot_data_indicator_for_two_sensors: list = field(
+        default_factory=lambda: [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)])
+    plot_data_plotter_for_two_sensors: list = field(
+        default_factory=lambda: [(0, 2), (1, 2)])
+
+@dataclass
+class _RecordingSetting:
+    device_name_prefix: str = "Dev"
+    device_ids:  List[int] = field(default_factory=lambda: [1])
+    ask_filename: bool = False
+    remote_control: bool = False
+    calibration_folder: str = "calibration"
+    calibration_files: List[str] = field(default_factory=lambda: ["FT9334.cal"])
+    zip_data: bool = True
+    write_Fx: bool = True
+    write_Fy: bool = True
+    write_Fz: bool = True
+    write_Tx: bool = False
+    write_Ty: bool = False
+    write_Tz: bool = False
+    write_trigger1: bool = False
+    write_trigger2: bool = False
+    lsl_stream: bool = False
+    reverse_scaling: dict = field(default_factory=lambda: {"1": ["Fz"], "2": ["Fz"]})
+    convert_to_forces: bool = True
+    priority: str = "normal"
+
+    def __post_init__(self):
+        if isinstance(self.device_ids, int):
+            self.device_ids = [self.device_ids]
+        if isinstance(self.calibration_files, str):
+            self.calibration_files = [self.calibration_files]
+
+
+class GUISettings(object):
+
+    def __init__(self, filename):
+        # defaults
+        self.gui = _GUISettings()
+        self.gui_section = "GUI"
+
+        self.recording = _RecordingSetting()
+        self.recording_section = "Recording"
+
+        self.filename = filename
+        if os.path.isfile(self.filename):
+            self.load()
+        else:
+            self.save() # defaults
+
+    def _asdict(self):
+        return {self.recording_section: self.recording.__dict__,
+             self.gui_section: self.gui.__dict__}
+
+    def set_gui_settings(self, gui_setting_dict):
+        self.gui = _GUISettings(**gui_setting_dict)
+
+    def set_recording_setting(self, recording_setting_dict):
+        self.recording = _RecordingSetting(**recording_setting_dict)
+
+    def load(self, filename=None):
+        if filename is not None:
+            self.filename = filename
+        with open(self.filename, 'r', encoding='utf-8') as fl:
+            d = tomlkit.load(fl)
+        self.set_gui_settings(d[self.gui_section])
+        self.set_recording_setting(d[self.recording_section])
+
+    def save(self):
+        with open(self.filename, 'w', encoding='utf-8') as fl:
+            tomlkit.dump(self._asdict(), fl)
+
+    def recording_as_json(self):
+        return json.dumps(self.recording.__dict__)
+
+settings = GUISettings(filename="pyForceDAQ.defaults.settings.toml")

{pyforcedaq-2.0.1.dev0 → pyforcedaq-2.0.1.dev2}/src/pyforcedaq/gui/launcher.py

@@ -1,13 +1,13 @@
 import sys
 from os import path
+from typing import List
 
 import FreeSimpleGUI as _sg
 
 from .. import USE_MOCK_SENSOR, __version__
-from .._lib.misc import find_calibration_file
 from .._lib.types import PollingPriority
 from .._lib.udp_connection import UDPConnection
-from ._run import run as _gui_run
+from ._run import run_settings as _gui_run
 from ._settings import settings
 
 
@@ -37,23 +37,25 @@ def _s2l(csv_string, is_integer=False, is_float=False): # convert csv string to
     return rtn
 
 
-def _check_sensor_calibration_settings(device_ids, sensor_names,
-                                       calibration_folder):
+def _check_sensor_calibration_settings(device_ids: List[int],
+                                       calibrations_files : List[str],
+                                       calibration_folder :str):
     rtn = []
     for x, d_id in enumerate(device_ids):
         error = False
         try:
-            sensor_name = sensor_names[x]
-        except:
-            sensor_name = "??"
-            error = True
-        try:
-            cal = find_calibration_file(calibration_folder=calibration_folder,
-                                    sensor_name=sensor_name)
-        except:
-            cal = "NO CALIBRATION"
+            cal_file = calibrations_files[x]
+        except KeyError:
+            cal_file = "??"
             error = True
-        rtn.append([d_id, sensor_name, cal, error])
+
+        if not error:
+            cal = path.join(calibration_folder, cal_file)
+            if not path.isfile(cal):
+                cal = "NOT FOUND"
+                error = True
+
+        rtn.append([d_id, cal_file, cal, error])
 
     return rtn
 
@@ -68,7 +70,7 @@ def _windows_run():
 
     for d_id, name, cal, error in _check_sensor_calibration_settings(
                                                 s.device_ids,
-                                                s.sensor_names,
+                                                s.calibration_files,
                                                 s.calibration_folder):
         if error:
             col = "red"
@@ -135,8 +137,8 @@ def _window_settings():
                  [[_sg.Text("Folder:", size=(5, 1)), _sg.InputText(
                      s.calibration_folder, size=(23, 1), key="cal_dir"),
                   _sg.FolderBrowse(size=(6, 1))],
-                 _input_text_list("Sensor Names:", s.sensor_names,
-                          key="sensor_names")
+                 _input_text_list("Cal-files:", s.calibration_files,
+                          key="calibration_files")
                  ])])
 
     layout.append([_sg.Frame('Record Forces & Torques',
@@ -190,7 +192,7 @@ def _window_settings():
         except:
             event = "Error"
 
-        key = "sensor_names"
+        key = "calibration_files"
         try:
             d[key] = _s2l(values[key])
         except:
@@ -207,7 +209,7 @@ def _window_settings():
         main_path = path.split(sys.modules['__main__'].__file__)[0] + path.sep
         d["calibration_folder"] = values["cal_dir"].replace(main_path, "")
 
-        settings.set_recoding_setting(d)
+        settings.set_recording_setting(d)
         settings.save()
 
     window.close()
@@ -220,9 +222,8 @@ def run():
     s = settings.recording
     settings_error = False
     n_sensor = len(s.device_ids)
-    if n_sensor != len(s.sensor_names):
-        _sg.PopupError("Number of devices IDs and sensor names are "
-                       "not equal.")
+    if n_sensor != len(s.calibration_files):
+        _sg.PopupError("Number of devices IDs and calibration files are not equal.")
         settings_error = True
 
     if not path.isdir(s.calibration_folder):

pyforcedaq-2.0.1.dev0/src/pyforcedaq/gui/__init__.py

@@ -1,6 +0,0 @@
-from ._run import (
-    run,
-    run_with_options,  # for running with options from Python script
-)
-from ._settings import settings  ## read settings
-

pyforcedaq-2.0.1.dev0/src/pyforcedaq/gui/_settings.py

@@ -1,98 +0,0 @@
-import collections
-import json
-import os
-
-import tomlkit
-
-_GUISettings = collections.namedtuple('GUISettings', 'sampling_rate '
-        'level_detection_parameter window_font moving_average_size '
-        'screen_refresh_interval_indicator gui_screen_refresh_interval_plotter '
-        'data_min_max plotter_pixel_min_max indicator_pixel_min_max plot_axis '
-        'plot_data_indicator_for_single_sensor plot_data_plotter_for_single_sensor '
-        'plot_data_indicator_for_two_sensors plot_data_plotter_for_two_sensors')
-
-_RecordingSetting = collections.namedtuple('RecordingSetting',
-          'device_name_prefix device_ids sensor_names remote_control '
-          'ask_filename calibration_folder '
-          ' zip_data write_Fx write_Fy '
-          'write_Fz write_Tx write_Ty write_Tz  write_trigger1 '
-          'write_trigger2  has_lsl_stream reverse_scaling convert_to_forces priority')
-
-
-class GUISettings(object):
-
-    def __init__(self, filename):
-
-        # defaults
-        self.gui = _GUISettings(
-            sampling_rate = 1000,
-            level_detection_parameter = "Fz",
-            window_font = "freemono",
-            moving_average_size = 5,
-            screen_refresh_interval_indicator = 300,
-            gui_screen_refresh_interval_plotter = 50,
-            data_min_max = [-5, 30],
-            plotter_pixel_min_max = [-250, 250],
-            indicator_pixel_min_max = [-150, 150],
-            plot_axis = False,
-            plot_data_indicator_for_single_sensor = [(0, 0), (0, 1), (0, 2), (0, 3),
-                                                     (0, 4), (0, 5)],  # sensor, parameter
-            plot_data_plotter_for_single_sensor = [(0, 0), (0, 1), (0, 2)],
-                              # plotter can't plot torques # TODO
-
-            plot_data_indicator_for_two_sensors = [(0, 0), (0, 1), (0, 2), (1, 0),
-                                                   (1, 1), (1, 2)],  # sensor,
-                              # parameter
-            plot_data_plotter_for_two_sensors = [(0, 2),
-                                                 (1, 2)],
-                              # plotter can't plot torques
-        )
-        self.gui_section = "GUI"
-
-        self.recording = _RecordingSetting(device_name_prefix="Dev",
-                       device_ids = [1],
-                       sensor_names = ["FT9334"],
-                       calibration_folder="calibration",
-                       reverse_scaling = {"1": ["Fz"], "2":["Fz"]},  # key: device_id, parameter. E.g.:if x & z dimension of sensor 1 and z dimension of sensor 2 has to be flipped use {1: ["Fx", "Fz"], 2: ["Fz"]}
-                       remote_control=False, ask_filename= False, write_Fx=True,
-                       write_Fy=True, write_Fz=True, write_Tx=False, write_Ty=False,
-                       write_Tz=False, write_trigger1=True, write_trigger2=False,
-                       has_lsl_stream=False,
-                       zip_data=True, convert_to_forces=True,
-                       priority='normal') # default recording settings
-        self.recording_section = "Recording"
-
-        self.filename = filename
-        if os.path.isfile(self.filename):
-            self.load()
-        else:
-            self.save() # defaults
-
-    def _asdict(self):
-        return {self.recording_section: self.recording._asdict(),
-             self.gui_section: self.gui._asdict()}
-
-    def set_gui_settings(self, gui_setting_dict):
-        self.gui = _GUISettings(**gui_setting_dict)
-
-    def set_recoding_setting(self, recording_setting_dict):
-        self.recording = _RecordingSetting(**recording_setting_dict)
-
-    def load(self, filename=None):
-        if filename is not None:
-            self.filename = filename
-        with open(self.filename, 'r') as fl:
-            d = tomlkit.load(fl)
-        self.set_gui_settings(d[self.gui_section])
-        self.set_recoding_setting(d[self.recording_section])
-
-
-    def save(self):
-        with open(self.filename, 'w') as fl:
-            tomlkit.dump(self._asdict(), fl)
-
-
-    def recording_as_json(self):
-        return json.dumps(self.recording._asdict())
-
-settings = GUISettings(filename="pyForceDAQ.defaults.settings.toml")