pyForceDAQ 2.0.1.dev0__py3-none-any.whl → 2.0.1.dev1__py3-none-any.whl

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/__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/_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/_lib/types.py

@@ -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'

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/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/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/force/sensor.py

@@ -7,11 +7,12 @@ __author__ = 'Oliver Lindemann'
 
 import ctypes as ct
 from copy import copy
+from pathlib import Path
 
 import numpy as np
+from icecream import ic
 
 #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,7 +23,7 @@ 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,
@@ -62,13 +63,7 @@ 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)):
@@ -105,7 +100,8 @@ 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":
+        ic(self.DAQ_TYPE)
+        if self.DAQ_TYPE == "mock_sensor":
             self._atidaq = None
             self.convert_to_FT = False
         else:

pyforcedaq/gui/__init__.py

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

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,
@@ -368,25 +370,25 @@ def run(settings_file: str | None = None):
                         has_lsl_stream=settings.recording.has_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,
+                     has_lsl_stream: bool = False,
+                     polling_priority: str | None = None):
 
     """start gui
     remote_control should be None (ask) or True or False
@@ -401,27 +403,30 @@ 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,
@@ -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/gui/_settings.py

@@ -1,65 +1,80 @@
-import collections
 import json
 import os
+from copy import deepcopy
+from dataclasses import dataclass, field
+from typing import List
 
 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')
+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)])
+
+    def update_from_dict(self, d):
+        for key, value in d.items():
+            setattr(self, key, value)
+
+@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 = True
+    write_trigger2: bool = False
+    has_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]
+
+    def update_from_dict(self, d):
+        for key, value in d.items():
+            ic(key, value)
+            setattr(self, key, value)
 
 
 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 = _GUISettings()
         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 = _RecordingSetting()
         self.recording_section = "Recording"
 
         self.filename = filename
@@ -69,30 +84,28 @@ class GUISettings(object):
             self.save() # defaults
 
     def _asdict(self):
-        return {self.recording_section: self.recording._asdict(),
-             self.gui_section: self.gui._asdict()}
+        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_recoding_setting(self, recording_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') as fl:
+        with open(self.filename, 'r', encoding='utf-8') as fl:
             d = tomlkit.load(fl)
         self.set_gui_settings(d[self.gui_section])
-        self.set_recoding_setting(d[self.recording_section])
-
+        self.set_recording_setting(d[self.recording_section])
 
     def save(self):
-        with open(self.filename, 'w') as fl:
+        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._asdict())
+        return json.dumps(self.recording.__dict__)
 
-settings = GUISettings(filename="pyForceDAQ.defaults.settings.toml")
+settings = GUISettings(filename="pyForceDAQ.defaults.settings.toml")

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.dist-info → pyforcedaq-2.0.1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyForceDAQ
-Version: 2.0.1.dev0
+Version: 2.0.1.dev1
 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.dist-info → pyforcedaq-2.0.1.dev1.dist-info}/RECORD

@@ -1,18 +1,18 @@
-pyforcedaq/__init__.py,sha256=3HvOhmYl8G5Z6JTbI_N4HE00d6YF2HnzGclza4z0qUY,1164
-pyforcedaq/__main__.py,sha256=c6QAtgcrP231FssQXHoLSD5q23u-sSMDAEZU_ilUw8E,1029
+pyforcedaq/__init__.py,sha256=esQLa14fkmOHX5vEjv9AGAB6x5ETZ-EbTSDSZNSSoEw,1151
+pyforcedaq/__main__.py,sha256=TkcXcjMoypKTpi5cmG5yfJRaRHzpAGuMyRysl1bPLZ4,1002
 pyforcedaq/_lib/__init__.py,sha256=GBiextmC_Xz9iMQlLBnU1qsw7YFVQaiZ8nV5ln3B7Wk,32
 pyforcedaq/_lib/lsl.py,sha256=6bLniyIy2hWB36-uclrO-9WJZogV2PoY1Lt2qq5JaR4,1520
-pyforcedaq/_lib/misc.py,sha256=13XJePZPYEkTuDbtoM7rWC4Abih8Eils1Jsh6f_05hQ,4033
+pyforcedaq/_lib/misc.py,sha256=YiG2fTac9YFYgWZac4iQ1j7BBhFo-y80-231xk1Gzds,4622
 pyforcedaq/_lib/polling_time_profile.py,sha256=5EHSWMVii-bEKk6dkuClH6OZnbSSJjrvW6hIfizS988,1487
 pyforcedaq/_lib/process_priority_manager.py,sha256=3povqR0hT54K9TRQtxk-rc8JPakT3K6PH4Np8pNgydo,4196
 pyforcedaq/_lib/timer.py,sha256=MN192NvqxezW-C5-znse9p-sv0DdoPV6jVN3X8d6CYY,1111
-pyforcedaq/_lib/types.py,sha256=TQMSeSy6xl0yYs_CM-QPHu398jnkYzNk_msNEWYDeLQ,11963
+pyforcedaq/_lib/types.py,sha256=haJORth-LE38G2bUpZJ7oudd_UUjH6HVRANiAbBNABs,11978
 pyforcedaq/_lib/udp_connection.py,sha256=k6Ww8n9r7PdOzC0AJmzs-sC9eW8Jnij3EyUR0ASJHas,10254
-pyforcedaq/daq/__init__.py,sha256=xs5gwGrSuYTpQlHMin_x8xCZ9o1Z1FsYyStuNgVhNvc,652
-pyforcedaq/daq/_daq_read_Analog_pydaqmx.py,sha256=0jtLoY82CBq1UxoOQMaCylKAOs_AzpK6mL2UUIdkhsw,3568
-pyforcedaq/daq/_daq_read_analog_nidaqmx.py,sha256=MHUC83UnKbHYAlNWr5iuTFoGYJpSfB21cxkm41qS_Vg,2459
+pyforcedaq/daq/__init__.py,sha256=ZrRK8xFcoi523Rk9I7DQcY-LyCm21hFcmQOXP7VwwYw,716
 pyforcedaq/daq/_mock_sensor.py,sha256=GsNKDz87lAUIF8eRyP18s9b3gQy6WzL1r3sbKa1fur8,2076
-pyforcedaq/daq/_pyATIDAQ.py,sha256=AT0RxNcWHp1qaeCL0Gd0UZ9CmegVrumoDzDk1CWJ9lA,11211
+pyforcedaq/daq/_pyATIDAQ.py,sha256=IqTdz2nAxEC8ea_u9OQvvCmT-fbOwkP85FBHV3gyIfQ,11142
+pyforcedaq/daq/_use_nidaqmx.py,sha256=MHUC83UnKbHYAlNWr5iuTFoGYJpSfB21cxkm41qS_Vg,2459
+pyforcedaq/daq/_use_pydaqmx.py,sha256=0jtLoY82CBq1UxoOQMaCylKAOs_AzpK6mL2UUIdkhsw,3568
 pyforcedaq/daq/config.py,sha256=JinPGtz4WYBj8uLT9LZkzQq-fSe11st8A0acrjJ015o,481
 pyforcedaq/extras/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyforcedaq/extras/convert.py,sha256=N8r5gl0Te3GHafkggeC4btFD94nUwBzM9cctH1jiSEA,8601
@@ -22,21 +22,21 @@ pyforcedaq/extras/read_force_data.py,sha256=ZjrEHexz40OW8L8JlRFgAFxQuBAS8c66t2-j
 pyforcedaq/extras/remote_control.py,sha256=2Ka9Y6edTAnsIY-P46rzyLDj9ddOc51n4cJ2Mma_cKg,2204
 pyforcedaq/force/__init__.py,sha256=h9pQxFkwt_xOs1hrTYCiEPFr1Cg2XblxwyKEDuKH8rs,346
 pyforcedaq/force/_log.py,sha256=h2JbbLLJsrrh1U9HwEbY7iFdRW7FYxDbiZuIq5Z3sE0,541
-pyforcedaq/force/data_recorder.py,sha256=3JYhaNfewwKDNQxL70IJ5o0FKO49vcUH331K2udOrY8,12817
-pyforcedaq/force/sensor.py,sha256=-kvgXQJt524qVESKYzJhR9-il5NFzG0ybWNGA215Ouw,7010
+pyforcedaq/force/data_recorder.py,sha256=7hWM7WKD94uEv57_R1RydJwf7HAQBRyNN3gDRcN9cRc,12939
+pyforcedaq/force/sensor.py,sha256=ZdeK6pEedEosrk_4SlG3mEOji6zBRaopSg0oEV6ZBM8,6810
 pyforcedaq/force/sensor_process.py,sha256=gBZ4B3Z7CDz87QISUbMJ0tsSf-SBT1rbl3dxc0Eo-To,9319
-pyforcedaq/gui/__init__.py,sha256=4I96AJjZvVy3-HHl4XAhDLfwqHF5BzLWNxYjSr312L8,151
+pyforcedaq/gui/__init__.py,sha256=bB1kI51Oi3fK-x_J7ncaN8yZpvai-5-3sp7UHqDr-GY,147
 pyforcedaq/gui/_gui_status.py,sha256=0YJcxVX2G8VtbgRn0H9avZi1wY4R-1A8re3cJjojkl0,13987
 pyforcedaq/gui/_layout.py,sha256=obptKZgw9CgygiqDCDgbXu4Esyfb8btOZgxxdNzgXiE,4616
 pyforcedaq/gui/_level_indicator.py,sha256=cBB-5DOlvdc95rQQ12Gt5dvhNxSYQTbaq19FSdz4YnQ,1905
 pyforcedaq/gui/_pg_surface.py,sha256=TD4rQJsBMMiKoQDZTon35LvsEmyayCWfklJbm0iRl6c,2902
 pyforcedaq/gui/_plotter.py,sha256=KvSxg3M3mDRj0_oNtn6mll8D2LBrBoboNoUs9hJJSUs,8451
-pyforcedaq/gui/_run.py,sha256=E8VZWBfocUnG7--OAU-mZLWmbswduoggL2NlpuaxgHU,23053
+pyforcedaq/gui/_run.py,sha256=9IsWsnVVcRmk12aBxMPDVmNB0QcFLHVivpVIHBVQ8yg,23368
 pyforcedaq/gui/_scaling.py,sha256=XgdB7CXqzrBXNFT1Kul8t7mebqO9gojNxGzNIppj4Bg,1905
-pyforcedaq/gui/_settings.py,sha256=fFq8icXqQpT-LOCAqw2gkveWT_yVkg03tZvjFILRBaI,4173
+pyforcedaq/gui/_settings.py,sha256=rSn3OgOx7mTkS7RCH_v7YPhugTKsDivmKqgzE1FvPOI,3772
 pyforcedaq/gui/forceDAQ_logo.png,sha256=-bn6ZQQjKf2Pxd9mJ4r-wulibtjuv_bEkhG567GR1vc,15624
-pyforcedaq/gui/launcher.py,sha256=pC7-NgEBscisb9HnebTSbT0Lerh4duFYcy98_Uv85YE,8732
-pyforcedaq-2.0.1.dev0.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
-pyforcedaq-2.0.1.dev0.dist-info/entry_points.txt,sha256=0VDGqAldPs3uUCun3y9v4ue8Uae8n-D6-R5YpamgJwQ,56
-pyforcedaq-2.0.1.dev0.dist-info/METADATA,sha256=CoT4ws39sJLISvRO1mP2XAXI_RD2xeXb7VkbphLVKZo,601
-pyforcedaq-2.0.1.dev0.dist-info/RECORD,,
+pyforcedaq/gui/launcher.py,sha256=5IjHTCU65bsoctr52k-w9L6MBTJOW4gN6Wm0PItUwX0,8753
+pyforcedaq-2.0.1.dev1.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
+pyforcedaq-2.0.1.dev1.dist-info/entry_points.txt,sha256=0VDGqAldPs3uUCun3y9v4ue8Uae8n-D6-R5YpamgJwQ,56
+pyforcedaq-2.0.1.dev1.dist-info/METADATA,sha256=4RVrVMtGkSX5ibhek7BBHpWW4P25Qikz70QB2hk0VxQ,601
+pyforcedaq-2.0.1.dev1.dist-info/RECORD,,