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

pyforcedaq/__init__.py

@@ -7,9 +7,8 @@ launch the GUI force from your Python program:
 ``
     from pyforcedaq import gui
 
-    gui.run(remote_control=False,
-              ask_filename=True,
-               calibration_file="FT_sensor1.cal")
+    gui.run(ask_filename=True,
+               calibration_file="FT_sensor1.cal") TODO
 ``
 
 
@@ -18,10 +17,6 @@ import relevant stuff to program your own force:
     from pyforcedaq import force
 ``
 
-import relevant stuff for remote control of the GUI force:
-``
-    from pyforcedaq import remote_control
-``
 
 For function to support data handling see the folder pyForceDAQ/analysis
 

pyforcedaq/__main__.py

@@ -24,17 +24,24 @@ def cli():
         help="Run with launcher GUI to edit settings and start recording",
     )
 
+    parser.add_argument(
+        "-o", "--omit-launcher",
+        action="store_true",
+        default=False,
+        help="Omit launcher GUI and start recording directly",
+    )
+
     args = parser.parse_args()
 
-    if args.launcher:
+    if not args.omit_launcher:
         if len(args.SETTINGS_FILE) > 0:
             print("Can't use launcher and settings file")
             exit()
 
         from .gui import launcher
-        return launcher.run()
+        return launcher.run_launcher()
     else:
-        gui.run_settings(args.SETTINGS_FILE)
+        gui.run_settings_file(args.SETTINGS_FILE)
 
 
 

pyforcedaq/{force → _lib}/_log.py

@@ -1,6 +1,7 @@
+import logging
 import os
 import sys
-import logging
+
 
 def set_logging(data_directory, log_file):
     base_dir = os.path.split(sys.argv[0])[0]

pyforcedaq/_lib/clock.py

@@ -0,0 +1,40 @@
+"""A high-resolution monotonic timer based on LSL's local_clock() function.
+"""
+
+
+from time import sleep
+
+from pylsl import local_clock
+
+
+def local_clock_ms():
+    """Returns the current time in milliseconds, based on LSL's local_clock()"""
+    return local_clock() * 1000
+
+def wait_ms(waiting_time: int | float, looptime : int = 200) -> None:
+    """Wait for a certain amount of milliseconds.
+    """
+    start = local_clock_ms()
+    if waiting_time > looptime:
+        sleep((waiting_time - looptime) / 1000)
+    while local_clock_ms() < start + waiting_time:
+        pass
+
+class StopWatch(object):#
+    """A simple timer"""
+
+    def __init__(self):
+        self._init_time = local_clock()
+
+    def reset_stopwatch(self):
+        """Reset the stopwatch time to zero.
+        """
+        self._init_time = local_clock()
+
+    @property
+    def time(self) -> float:
+        return local_clock() - self._init_time
+
+    @property
+    def time_ms(self) -> float:
+        return self.time * 1000

pyforcedaq/{force → _lib}/data_recorder.py

@@ -7,15 +7,21 @@ __author__ = "Oliver Lindemann"
 import atexit
 import gzip
 import logging
+from fileinput import filename
+from io import TextIOWrapper
 from pathlib import Path
 from time import asctime, localtime, strftime
+from typing import List
 
-from pyforcedaq._lib import timer
+from icecream import ic
 
 from .. import __version__ as forceDAQVersion
-from .._lib.process_priority_manager import ProcessPriorityManager
-from .._lib.timer import app_clock
-from .._lib.types import (
+from . import _log
+from .clock import wait_ms
+from .process_priority_manager import ProcessPriorityManager
+from .sensor_process import SensorProcess
+from .settings import RecordingSettings, SensorSettings
+from .types import (
     TAG_COMMENTS,
     TAG_DAQEVENT,
     TAG_UDPDATA,
@@ -24,20 +30,19 @@ from .._lib.types import (
     PollingPriority,
     UDPData,
 )
-from .._lib.types import GUIRemoteControlCommands as RemoteCmd
-from .._lib.udp_connection import UDPConnectionProcess
-from .sensor import SensorSettings
-from .sensor_process import SensorProcess
+from .udp_connection import UDPConnectionProcess
+
+_log.set_logging(data_directory="data", log_file="recording.log")
 
 NEWLINE = "\n"
 
 class DataRecorder(object):
     """handles multiple sensors and udp connection"""
 
-    def __init__(self, force_sensor_settings:SensorSettings | list,
-                 poll_udp_connection=False,
-                 write_deviceid = False,
-                 polling_priority:str | None = None):
+    def __init__(self,
+                 recording_settings: RecordingSettings,
+                 force_sensor_settings:SensorSettings | List[SensorSettings],
+                 poll_udp_connection: bool = False):
 
 
         """queue_data will be saved
@@ -47,13 +52,10 @@ class DataRecorder(object):
         {REALTIME} or {NORMAL} or None
         """
 
-        self._write_deviceid = write_deviceid
-
         if not isinstance(force_sensor_settings, list):
             force_sensor_settings = [force_sensor_settings]
-        # write forces and triggers as define in sensor1
-        self._write_forces = force_sensor_settings[0].array_write_forces()
-        self._write_trigger = force_sensor_settings[0].array_write_trigger()
+
+        self.recording_settings = recording_settings
 
         # create sensor processes
         self._force_sensor_processes =[]
@@ -62,7 +64,8 @@ class DataRecorder(object):
             if not isinstance(fs, SensorSettings):
                 raise RuntimeError("Recorder needs a list of Force Sensor Settings!")
             else:
-                fst = SensorProcess(settings = fs,
+                fst = SensorProcess(sensor_settings = fs,
+                                    recording_settings=recording_settings,
                                     pipe_buffered_data_after_pause=True)
                 fst.start()
                 event_trigger.append(fst.event_trigger)
@@ -70,20 +73,19 @@ class DataRecorder(object):
 
         # create udp connection process
         if poll_udp_connection:
-            self.udp = UDPConnectionProcess(event_trigger=event_trigger,
-                                            event_ignore_tag = RemoteCmd.COMMAND_STR)
+            self.udp = UDPConnectionProcess(event_trigger=event_trigger)
             self.udp.start()
         else:
             self.udp = None
 
-        # process managing
+        # 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 polling_priority is not None:
+        if self.recording_settings.priority is not None:
            level = PollingPriority.NORMAL
         else:
-            level = PollingPriority.get_priority(polling_priority)
+            level = PollingPriority.get_priority(self.recording_settings.priority)
         self._proc_manager.set_subprocess_priorities(level=level, disable_gc=False)
 
         logging.info("Main process priority: %s", self._proc_manager.get_main_priority())
@@ -92,9 +94,13 @@ class DataRecorder(object):
         self._is_recording = False
         self._file = None
         self._daq_event = []
-        self.filename: str | None = None
+        self.path_open_file = Path("")
         atexit.register(self.quit)
 
+    @property
+    def is_saving_data(self):
+        """Property indicates whether a data file is open"""
+        return self._file is not None
 
     @property
     def is_alive(self):
@@ -149,16 +155,16 @@ class DataRecorder(object):
         buffer = []
         while True:
             try:
-                data = self.udp.receive_queue.get_nowait()
-            except:
+                data = self.udp.receive_queue.get_nowait() # type: ignore
+            except AttributeError:
                 # until queue empty or no udp connection
                 break
             buffer.append(data)
         if len(buffer)>0:
-            self._save_data(buffer)
+            self._write_data(buffer)
         return buffer
 
-    def _save_data(self, data_buffer: list,
+    def _write_data(self, data_buffer: list,
                    recording_screen=None,
                    float_decimal_places: int = 4) -> None:
         """ writes data to disk and set counters
@@ -168,18 +174,20 @@ class DataRecorder(object):
         #DOC output format
 
         BLOCKSIZE = 10000 # for recording screen feedback only
-
+        write_forces = self.recording_settings.array_write_forces()
+        write_trigger = self.recording_settings.array_write_trigger()
+        write_deviceid = len(self.recording_settings.device_labels)>1
         float_format = "{0:." + str(float_decimal_places) + "f},"
         buffer_len = len(data_buffer)
         for c, d in enumerate(data_buffer):
             if self._file is not None:
                 if isinstance(d, ForceSensorData):
                     line = f"{d.time}, {d.acquisition_delay},"
-                    if self._write_deviceid:
-                        line += f"{d.device_id},"
-                    for x in d.selected_forces(select=self._write_forces):
+                    if write_deviceid:
+                        line += f"{d.sensor_id},"
+                    for x in d.selected_forces(select=write_forces):
                         line += float_format.format(x)
-                    for x in d.selected_trigger(select=self._write_trigger):
+                    for x in d.selected_trigger(select=write_trigger):
                         if isinstance(x, int):
                             line += f"{x},"
                         else:
@@ -190,8 +198,7 @@ class DataRecorder(object):
                     self._file_write(f"{TAG_DAQEVENT},{d.time},{str(d.code)}" + NEWLINE)
 
                 elif isinstance(d, UDPData):
-                    if not d.is_remote_control_command:
-                        self._file_write(f"{TAG_UDPDATA},{d.time},{d.unicode}" + NEWLINE)
+                    self._file_write(f"{TAG_UDPDATA},{d.time},{d.unicode}" + NEWLINE)
 
             if recording_screen is not None and c % BLOCKSIZE == 0:
                 recording_screen.stimulus(
@@ -199,16 +206,19 @@ class DataRecorder(object):
                                                        buffer_len//BLOCKSIZE)).present()
 
     def _file_write(self, s: str) -> None:
-        self._file.write(s.encode())
 
-    def save_daq_event(self, code, time: float | None = None) -> None:
+        if isinstance(self._file, gzip.GzipFile):
+            self._file.write(s.encode("utf-8"))
+        elif isinstance(self._file, TextIOWrapper):
+            self._file.write(s)
+
+
+    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
 
         """
-        if time is None:
-            time = app_clock.time
         self._daq_event.append(DAQEvents(time = time, code = code))
 
 
@@ -250,19 +260,19 @@ class DataRecorder(object):
         for fsp in self._force_sensor_processes:
             fsp.pause_polling()
 
-        timer.wait(500)
+        wait_ms(500)
 
         # get data
         for fsp in self._force_sensor_processes:
             buffer = fsp.get_buffer()
-            self._save_data(buffer, recording_screen)
+            self._write_data(buffer, recording_screen)
             data.extend(buffer)
 
         # udp event
         data.extend(self.process_and_write_udp_events())
 
         # soft trigger
-        self._save_data(self._daq_event)
+        self._write_data(self._daq_event)
         data.extend(self._daq_event)
         self._daq_event = []
         return data
@@ -288,12 +298,11 @@ class DataRecorder(object):
         for x in self._force_sensor_processes:
             x.event_bias_is_available.wait()
 
-    def open_data_file(self, filename: str,
+    def open_data_file(self,
+                       filename: str | Path,
                        subdirectory: str = "data",
-                       time_stamp_filename: bool = False,
                        varnames: bool = True,
-                       comment_line: str = "",
-                       zipped: bool = False) -> Path:
+                       comment_line: str = "") -> Path:
         """Create a data file
 
         Only if data file has been opened, data will be saved!
@@ -311,9 +320,6 @@ class DataRecorder(object):
             write variable names in first line of data output
         comment_line : string, optional
             add some comments at the beginning of the data output file
-        zippers : boolean, optional
-            are the data zipped or not. Note: Saving zipped data after pause
-            takes much longer.
 
         Returns
         -------
@@ -321,68 +327,57 @@ class DataRecorder(object):
                 full path the actually used file (incl. timestamp)
 
         """
-        data_dir = Path.cwd() / subdirectory
-        data_dir.mkdir(exist_ok=True)
         self.close_data_file()
 
-        if filename is None or len(filename) == 0:
-            filename = "daq_recording.csv"
-
-        if zipped:
-            suffix = ".gz"
+        # create filename
+        data_dir = Path.cwd() / subdirectory
+        data_dir.mkdir(exist_ok=True)
+        if self.recording_settings.zip_data:
+            filename = Path(filename).with_suffix(".csv.gz")
         else:
-            suffix = ""
+            filename = Path(filename).with_suffix(".csv")
 
-        cnt = 0
         while True:
-            flname = filename
-            if cnt>0:
-                x = flname.find(".")
-                if x<0:
-                    x = len(flname)
-                flname = flname[:x] + "_{0}".format(cnt) + flname[x:]
-
-            if time_stamp_filename:
-                self.filename = flname + "_" + \
-                        strftime("%Y%m%d%H%M", localtime()) + suffix
-            else:
-                self.filename = flname + suffix
-
-            full_path_file = data_dir / self.filename
-            if full_path_file.is_file():
+            self.path_open_file = data_dir / filename
+            if self.path_open_file.is_file():
                 # print "data file already exists, adding counter"
-                cnt += 1
+                filename = Path(filename.stem + "_" + strftime("%m%d%H%M", localtime()) + \
+                                filename.suffix)
             else:
                 break
 
-        if zipped:
-            self._file = gzip.open(full_path_file, 'w+')
+        if self.recording_settings.zip_data:
+            self._file = gzip.open(self.path_open_file, 'w')
         else:
-            self._file = open(full_path_file, 'w+')
-        print("Data file: {}".format(full_path_file))
+            self._file = open(self.path_open_file, 'w')
+        print("Data file: {}".format(self.path_open_file))
 
         self._file_write(TAG_COMMENTS + "Recorded at {0} with pyForceDAQ {1}\n".format(
             asctime(localtime()), forceDAQVersion))
-        logging.info("new file: {}".format(filename))
+        logging.info("new file: {}".format(self.path_open_file))
 
         for s in self.sensor_settings_list:
-            txt = " Sensor: id={0}, name={1}, cal-file={2}\n".format(s.device_id,
-                                s.sensor_name, s.calibration_file)
+            txt = f" Sensor: label={s.device_label}, cal-file={s.calibration_file}\n"
             self._file_write(TAG_COMMENTS + txt)
 
         if len(comment_line)>0:
             self._file_write(TAG_COMMENTS + comment_line + "\n")
+
         if varnames:
+            write_forces = self.recording_settings.array_write_forces()
+            write_trigger = self.recording_settings.array_write_trigger()
+            write_deviceid = len(self.recording_settings.device_labels)>1
             line = "time,delay,"
-            if self._write_deviceid: line += "device_tag,"
+            if write_deviceid:
+                line += "device_tag,"
             for x in range(6):
-                if self._write_forces[x]:
+                if write_forces[x]:
                     line += ForceSensorData.forces_names[x] + ","
-            if self._write_trigger[0]: line += "trigger1,"
-            if self._write_trigger[1]: line += "trigger2,"
+            if write_trigger[0]: line += "trigger1,"
+            if write_trigger[1]: line += "trigger2,"
             self._file_write(line[:-1] + NEWLINE)
 
-        return full_path_file
+        return self.path_open_file
 
     def close_data_file(self) -> None:
         """Close the data file
@@ -394,3 +389,4 @@ class DataRecorder(object):
         if self._file is not None:
             self._file.close()
             self._file = None
+            self.path_open_file = Path("")

pyforcedaq/_lib/lsl.py

@@ -12,45 +12,64 @@ from pylsl import (
 )
 
 
-def init(
-    name: str,
-    n_channels: int,
-    stream_id: str,
-    freq: int,
-    channel_format: int,
-    metadata: dict | None = None,
-) -> StreamOutlet:
-    """
-    Initialise a LSL stream
-
-    Args:
-        name: name of the stream
-        n_channels: number of channels per sample
-        channel_format: format/type of each channel (ex: string, int, ...)
-                        same format for each channel
-        stream_id: unique identifier of the stream
-        content_type: content type of stream. By convention LSL uses the content
-            types defined in the XDF file format specification where
-            applicable
-        freq: sampling rate in Hz
-
-    Return:
-        outlet: StreamOulet to push samples with LSL
-    """
-    # LSL
-    # StreamInfo takes name t
-    info = StreamInfo(name, "force",
-                      channel_count=n_channels,
-                      nominal_srate=freq,
-                      channel_format=channel_format,
-                      source_id=stream_id)
-
-    # Check if there is metadata to add to the lsl stream
-    if metadata:
-        # Get xml object of the stream created earlier
-        xml_info = info.desc()
-        # Add meta data to xml object
-        for key, data in metadata.items():
-            xml_info.append_child_value(key, str(data))
-
-    return StreamOutlet(info)
+class LSLSream():
+
+    def __init__(self):
+        self.outlet = None
+        self._is_init = False
+
+    @property
+    def is_init(self):
+        return self._is_init
+
+    def init(self,
+        name: str,
+        n_channels: int,
+        stream_id: str,
+        freq: int,
+        channel_format: int,
+        metadata: dict | None = None,
+    ):
+        """
+        Initialise a LSL stream
+
+        Args:
+            name: name of the stream
+            n_channels: number of channels per sample
+            channel_format: format/type of each channel (ex: string, int, ...)
+                            same format for each channel
+            stream_id: unique identifier of the stream
+            content_type: content type of stream. By convention LSL uses the content
+                types defined in the XDF file format specification where
+                applicable
+            freq: sampling rate in Hz
+
+        Return:
+            outlet: StreamOulet to push samples with LSL
+        """
+        if self._is_init:
+            return
+
+        info = StreamInfo(name, "force",
+                        channel_count=n_channels,
+                        nominal_srate=freq,
+                        channel_format=channel_format,
+                        source_id=stream_id)
+
+        # Check if there is metadata to add to the lsl stream
+        if metadata:
+            # Get xml object of the stream created earlier
+            xml_info = info.desc()
+            # Add meta data to xml object
+            for key, data in metadata.items():
+                xml_info.append_child_value(key, str(data))
+
+        self._is_init = True
+        self.outlet = StreamOutlet(info)
+
+    def push_sample(self, sample: list):
+        """Push a sample to the LSL stream if it is initialized."""
+        if not self._is_init:
+            # Don't do anything
+            return
+        self.outlet.push_sample(sample)  # type: ignore

pyforcedaq/_lib/misc.py

@@ -1,6 +1,4 @@
-from os import listdir, path
-
-from .timer import get_time_ms
+from .clock import local_clock_ms
 
 
 def N2g(N):
@@ -9,9 +7,9 @@ def N2g(N):
 
 class MinMaxDetector(object):
 
-    def __init__(self, start_value, duration):
+    def __init__(self, start_value, duration_ms):
         self._minmax = [start_value, start_value]
-        self._duration = duration
+        self._duration_ms = duration_ms
         self._level_change_time = None
 
     def process(self, value):
@@ -19,7 +17,7 @@ class MinMaxDetector(object):
         level change has occurred, otherwise None"""
 
         if self._level_change_time is not None:
-            if (get_time_ms() - self._level_change_time) >= self._duration:
+            if (local_clock_ms() - self._level_change_time) >= self._duration_ms:
                 return tuple(self._minmax)
 
             if value > self._minmax[1]:
@@ -28,7 +26,7 @@ class MinMaxDetector(object):
                 self._minmax[0] = value
 
         elif self._minmax[0] != value: # level change just occurred
-            self._level_change_time = get_time_ms()
+            self._level_change_time = local_clock_ms()
             return self.process(value)
 
         return None
@@ -37,12 +35,12 @@ class MinMaxDetector(object):
     def is_sampling_for_minmax(self):
         """true true if currently sampling for minmax"""
         return (self._level_change_time is not None) and \
-               (get_time_ms() - self._level_change_time) < self._duration
+               (local_clock_ms() - self._level_change_time) < self._duration_ms
 
-# def find_calibration_file(calibration_folder: str, sensor_name: str,
+# def find_calibration_file(calibration_folder: str, device_label: str,
 #                           calibration_suffix=".cal") -> str:
 
-#     needle = 'Serial="{0}"'.format(sensor_name)
+#     needle = 'Serial="{0}"'.format(device_label)
 #     calibration_files = []
 #     for x in listdir(path.abspath(calibration_folder)):
 #         filename = path.join(calibration_folder, x)
@@ -51,18 +49,18 @@ class MinMaxDetector(object):
 #                 for l in fl:
 #                     if l.find(needle)>0:
 #                         print("Found calibration file for sensor '{0}' : {1}.".format(
-#                             sensor_name, filename))
+#                             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(sensor_name))
+#         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(sensor_name))
+#         print("No calibration file found for sensor '{0}'.".format(device_label))
 #     exit()
 
 #Sensor History with moving average filtering and distance, velocity

pyforcedaq/_lib/polling_time_profile.py

@@ -1,26 +1,28 @@
 import numpy as np
 
-from .timer import get_time_ms
+from .clock import local_clock
 
 
 class PollingTimeProfile(object):
 
-    def __init__(self, timing_range=10):
+    def __init__(self, timing_range_ms=10):
         self._last = None
-        self._timing_range = 10
+        self._timing_range_ms = 10
         self._zero_cnt = 0
 
         #self._zero_time_polling_frequency = {}
-        self.profile_frequency = np.array([0] * (timing_range + 1))
+        self.profile_frequency = np.array([0] * (timing_range_ms + 1))
 
     def stop(self):
         self._last = None
 
-    def update(self, time_ms):
+    def update(self, time: float):
+
+        time_ms = int(time * 1000)
         if self._last is not None:
             d = time_ms - self._last
-            if d > self._timing_range:
-                d = self._timing_range
+            if d > self._timing_range_ms:
+                d = self._timing_range_ms
             self.profile_frequency[d] += 1
 
             #if d == 0:
@@ -35,7 +37,7 @@ class PollingTimeProfile(object):
         self._last = time_ms
 
     def tick(self):
-        self.update(get_time_ms())
+        self.update(local_clock())
 
     @property
     def profile_percent(self):