pyForceDAQ 2.0.0__py3-none-any.whl

pyforcedaq/extras/expyriment_daq_control.py

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+
+"""
+Expyriment convinient functions for the force DAQ remote control
+
+(c) O. Lindemann
+
+for two sensor setups
+
+"""
+
+from expyriment import control, io, misc, stimuli
+
+from . import remote_control as rc
+
+FORCE_SERVER_IP = "192.168.1.2"
+WEAK, FINE, STRONG = [0, 1, 2]
+STR_FULL_FORCE = u"kräftig"
+STR_LESS_FORCE = u"sacht"
+
+stopwatch = misc.Clock()
+udp = rc.init_udp_connection()
+print(udp)
+
+
+def runtimeerror(exp, text):
+    stimuli.TextScreen("ERROR", text).present()
+    exp.keyboard.wait()
+    control.end()
+    udp.send(rc.Command.QUIT)
+    exit()
+
+
+def start(exp, time_for_feedback=10):
+    """ returns true if feedback is OK
+    waits a particular time (in sec) for feedback and
+    """
+
+    udp.send(rc.Command.START)
+    stopwatch.reset_stopwatch()
+    while True:
+        rtn = udp.poll()
+        exp.keyboard.check()
+        if rtn == rc.Command.FEEDBACK_STARTED:
+            break
+        if stopwatch.stopwatch_time > time_for_feedback * 1000:
+            return False
+    return True
+
+
+def pause(exp, time_for_feedback=60 * 2):
+    """returns true if feedback is OK
+    waits a particular for feedback and
+    """
+
+    udp.send(rc.Command.PAUSE)
+    stopwatch.reset_stopwatch()
+    while True:
+        rtn = udp.poll()
+        exp.keyboard.check()
+        if rtn == rc.Command.FEEDBACK_PAUSED:
+            break
+        if stopwatch.stopwatch_time > time_for_feedback * 1000:
+            return False
+    return True
+
+
+# make connection #
+def make_connection(exp, experiment_name="force_daq"):
+    """hand shake and filename,
+    returns pyforcedaq version
+    """
+
+    stimuli.TextScreen("Prepare force recording", "press key if ready").present()
+    exp.keyboard.wait()
+    stimuli.BlankScreen().present()
+    while not udp.connect_peer(FORCE_SERVER_IP):
+        stimuli.TextScreen("ERROR while connecting to server",
+                           "try again or <ESC> to quit").present()
+        exp.keyboard.wait()
+        stimuli.BlankScreen().present()
+        exp.clock.wait(300)
+
+    stimuli.TextScreen("Connected", "").present()
+    exp.clock.wait(500)
+    udp.send(rc.Command.FILENAME.decode('utf-8', 'replace') + "{0}_{1}.csv".format(experiment_name, exp.subject))
+    rtn = udp.receive(5)  # paused
+    if rtn is None:
+        runtimeerror(exp, "Force server not responding")
+    version = rc.get_data(rc.Command.GET_VERSION)
+    stimuli.TextScreen("Connected", "Version " + version).present()
+    exp.clock.wait(1000)
+    return version
+
+
+def force_button_box_prepare(n_sensors=1):
+    udp.clear_receive_buffer()
+    udp.send(rc.Command.SET_LEVEL_CHANGE_DETECTION)
+    if n_sensors>1:
+        udp.send(rc.Command.SET_LEVEL_CHANGE_DETECTION2)
+
+
+def force_button_box_check():
+    """
+    changes to level
+    """
+    evt, level = rc.poll_multiple_events([rc.Command.CHANGED_LEVEL, rc.Command.CHANGED_LEVEL2])
+    if evt is not None:
+        if evt == rc.Command.CHANGED_LEVEL:
+            sensor = 1
+        else:
+            sensor = 2
+        return (sensor, level)
+    return (None, None)
+
+
+def force_button_box_wait(exp, duration=None, minimum_level=-1):
+    """
+    returns if one of two sensors changes its level
+    """
+
+    stopwatch.reset_stopwatch()
+    last_key = None
+    rt = None
+    force_button_box_prepare()
+    while not(duration is not None and stopwatch.stopwatch_time > duration):
+        sensor, level = force_button_box_check()
+        if sensor is not None:
+            if level>=minimum_level:
+                rt = stopwatch.stopwatch_time
+                break
+            else:
+                force_button_box_prepare()
+                sensor = None
+        last_key = exp.keyboard.check()
+        if last_key is not None:
+            break
+
+    return sensor, level, rt, last_key
+
+
+def wait_no_button_pressed(exp, feedback_stimulus=None, polling_intervall=500):
+    """level detection needs to be switch on
+    display feedback_stimulus (optional) if one button pressed
+    """
+    if rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
+                    rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
+        if feedback_stimulus is not None:
+            feedback_stimulus.present()
+        while rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
+                        rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
+            exp.keyboard.wait(duration=polling_intervall)
+
+
+############ further convenient functions
+def hold_check(exp, holding_time, background_stimulus=None,
+               n_sensors=2): # FIXME not checked for sensor=1
+    if background_stimulus is None:
+        background_stimulus = stimuli.BlankScreen()
+
+    background_stimulus.present()
+    background_stimulus.present()
+    udp.send("hold:test")
+
+    fine = stimuli.Circle(radius=20, colour=misc.constants.C_GREY, line_width=0)
+    too_low = stimuli.Circle(radius=20, colour=misc.constants.C_GREEN, line_width=0)
+    too_strong = stimuli.Circle(radius=20, colour=misc.constants.C_RED, line_width=0)
+    bkg = [stimuli.Circle(position=(-200, 0), radius=24, colour=misc.constants.C_BLACK, line_width=0),
+           stimuli.Circle(position=(200, 0), radius=24, colour=misc.constants.C_BLACK, line_width=0)]
+
+    key = None
+    stopwatch.reset_stopwatch()
+
+    while key is None and stopwatch.stopwatch_time < holding_time:
+        key = exp.keyboard.check()
+        udp.clear_receive_buffer()
+        lv = [rc.get_data(rc.Command.GET_THRESHOLD_LEVEL),
+              rc.get_data(rc.Command.GET_THRESHOLD_LEVEL2)]
+        for i in range(n_sensors):
+            bkg[i].clear_surface()
+            if lv[i] == WEAK:
+                too_low.plot(bkg[i])
+                stopwatch.reset_stopwatch()
+            elif lv[i] == STRONG:
+                too_strong.plot(bkg[i])
+                stopwatch.reset_stopwatch()
+            elif lv[i] == FINE:
+                fine.plot(bkg[i])
+            bkg[i].present(clear=False, update=False)
+            bkg[i].present(clear=False, update=False)
+        exp.screen.update()
+
+    background_stimulus.present()
+
+def _text2number_array(txt):
+    """helper function for textinput_thesholds """
+    rtn = []
+    try:
+        for x in txt.split(","):
+            rtn.append(float(x))
+        return rtn
+    except:
+        return None
+
+
+def textinput_thesholds(message="Enter thresholds"):
+    thresholds = _text2number_array(io.TextInput(message=message).get())
+    stimuli.BlankScreen().present()
+    if thresholds is not None:
+        if len(thresholds) != 2:
+            thresholds = None
+    return thresholds
+
+
+def threshold_menu(exp, thresholds, last_item="Ende"):
+    while True:
+        select = io.TextMenu(heading=u"Schwellen: " + str(thresholds),
+                             menu_items=["Schwellen Anpassen ",  # 0
+                                         "Halten",  # 1
+                                         last_item],
+                             background_colour=misc.constants.C_GREY,
+                             text_colour=misc.constants.C_BLACK,
+                             width=500)
+        x = select.get()
+        blank = stimuli.BlankScreen()
+        blank.present()
+
+        if x == 0:
+            new = textinput_thesholds()
+            if new is not None:
+                thresholds = new
+        elif x == 1:
+            if not start(exp):
+                stimuli.TextScreen("ERROR: Could not start recording",
+                                   "Press key to quit").present()
+                exp.keyboard.wait()
+                exit()
+            exp.clock.wait(500)
+            rc.set_force_thresholds(lower=thresholds[0], upper=thresholds[1])
+            hold_check(exp, holding_time=10000)
+            blank.present()
+            pause(exp)
+        else:
+            break
+
+    return thresholds

pyforcedaq/extras/opensesame_daq_control.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+
+"""
+Openseame Object or the force DAQ remote control
+
+(c) O. Lindemann
+
+v0.9
+
+"""
+
+from libopensesame.exceptions import osexception
+from libopensesame.experiment import experiment
+from openexp.canvas import canvas
+from openexp.keyboard import keyboard
+
+from . import remote_control as rc
+
+FORCE_SERVER_IP = "192.168.1.1"
+WEAK, FINE, STRONG = [0, 1, 2]
+
+class OpensesameDAQControl():
+
+    def __init__(self, opensesame_experiment):
+        """ OpenSesame clock and var"""
+
+        if isinstance(opensesame_experiment, experiment):
+            self._exp = opensesame_experiment
+        else:
+            raise osexception("opensesame_experiment needs to be an instance of " +\
+                    "opensesame.experiment.experiment")
+
+        self.clock = ExpyClock(self._exp.clock)
+        self.subject_number = self._exp.var.get(u'subject_nr')
+        self.experiment_name = self._exp.var.get(u'experiment_file').split('.')[0]
+        self.udp = rc.init_udp_connection()
+        self._exp.cleanup_functions.append(self.quit_recording)
+
+    def __del__(self):
+        self.quit_recording()
+
+    def start(self, time_for_feedback=10):
+        """ returns true if feedback is OK
+        waits a particular time (in sec) for feedback and
+        """
+
+        self.udp.send(rc.Command.START)
+        self.clock.reset_stopwatch()
+        kbd = keyboard(self._exp)
+        while True:
+            rtn = self.udp.poll()
+            kbd.get_key(timeout=0) # just for keyboard processing
+            if rtn == rc.Command.FEEDBACK_STARTED:
+                break
+            if self.clock.stopwatch_time > time_for_feedback*1000:
+                msg = "ERROR: Could not start recording <br/> Press key to quit"
+                cnv = canvas(self._exp)
+                cnv.text(msg)
+                cnv.show()
+                kbd.get_key()
+                self._exp.end()
+                exit()
+
+        return True
+
+    def stop(self):
+        self.udp.send(rc.Command.QUIT)
+
+    def quit_recording(self):
+        if self.udp is not None:
+            self.udp.send(rc.Command.QUIT)
+        self.udp = None
+
+    def pause(self, time_for_feedback=60 * 2, text_saving_time ="Please wait..."):
+        """returns true if feedback is OK (that means data are saved)
+        waits for a particular for feedback
+        """
+
+        self.udp.send(rc.Command.PAUSE)
+        self.clock.reset_stopwatch()
+        kbd = keyboard(self._exp)
+        if text_saving_time != None:
+            cnv = canvas(self._exp)
+            cnv.text(text_saving_time)
+            cnv.show()
+        while True:
+            rtn = self.udp.poll()
+            kbd.get_key(timeout=1)
+            if rtn == rc.Command.FEEDBACK_PAUSED:
+                break
+            if self.clock.stopwatch_time > time_for_feedback * 1000:
+                return False
+
+        if text_saving_time != None:
+            canvas(self._exp).show()
+
+        return True
+
+    # make connection #
+    def make_connection(self, ip=FORCE_SERVER_IP):
+        """hand shake and filename,
+        returns pyforcedaq version
+        """
+        kbd = keyboard(self._exp)
+        cnv = canvas(self._exp)
+
+        cnv.text("Prepare force recording <br> press key if ready")
+        cnv.show()
+        kbd.get_key()
+        canvas(self._exp).show()
+
+        while not self.udp.connect_peer(ip):
+            cnv = canvas(self._exp)
+            cnv.text("ERROR while connecting to server <br> try again or Q to quit")
+            cnv.show()
+            key = kbd.get_key()
+            if key[0] == u'q':
+                msg = "Experiment quitted by user!"
+                self.udp.send(rc.Command.QUIT)
+                print(msg)
+                self._exp.end()
+                exit()
+            canvas(self._exp).show()
+            self.clock.wait(300)
+
+        cnv = canvas(self._exp)
+        cnv.text("Connected")
+        cnv.show()
+        self.clock.wait(500)
+        self.udp.send(rc.Command.FILENAME.decode('utf-8', 'replace') + "{0}_{1}.csv".format(self.experiment_name,
+                                                                 self.subject_number))
+        rtn = self.udp.receive(5)  # paused
+        if rtn is None:
+            msg = "Force server not responding"
+            cnv = canvas(self._exp)
+            cnv.text(msg)
+            cnv.show()
+            kbd.get_key()
+            self.udp.send(rc.Command.QUIT)
+            print(msg)
+            self._exp.end()
+            exit()
+        version = rc.get_data(rc.Command.GET_VERSION)
+        if version is None:
+            version = "" # FIXME Why is version somethimes None
+        cnv = canvas(self._exp)
+        cnv.text("Connected <br> Version " + version)
+        cnv.show()
+        self.clock.wait(1000)
+        return version
+
+    def force_button_box_prepare(self, n_sensors=1):
+        self.udp.clear_receive_buffer()
+        self.udp.send(rc.Command.SET_LEVEL_CHANGE_DETECTION)
+        if n_sensors>1:
+            self.udp.send(rc.Command.SET_LEVEL_CHANGE_DETECTION2)
+
+    def force_button_box_check(self):
+        """
+        changes to level
+        """
+        evt, level = rc.poll_multiple_events([rc.Command.CHANGED_LEVEL,
+                                              rc.Command.CHANGED_LEVEL2])
+        if evt is not None:
+            if evt == rc.Command.CHANGED_LEVEL:
+                sensor = 1
+            else:
+                sensor = 2
+            return (sensor, level)
+        return (None, None)
+
+    def force_button_box_wait(self, duration=None, minimum_level=-1):
+        """
+        returns if one of two sensors changes its level
+        """
+
+        self.clock.reset_stopwatch()
+        kbd = keyboard(self._exp)
+        last_key = None
+        rt = None
+        self.force_button_box_prepare()
+        while not (duration is not None and self.clock.stopwatch_time > duration):
+            sensor, level = self.force_button_box_check()
+            if sensor is not None:
+                if level >= minimum_level:
+                    rt = self.clock.stopwatch_time
+                    break
+                else:
+                    self.force_button_box_prepare()
+                    sensor = None
+            last_key, _ = kbd.get_key(timeout=0)
+            if last_key is not None:
+                break
+
+        return sensor, level, rt, last_key
+
+    def wait_no_button_pressed(self, feedback_stimulus_text=None, polling_intervall=500):
+        """level detection needs to be switch on
+        display feedback_stimulus (optional) if one button pressed
+        """
+        if rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
+                        rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
+            if feedback_stimulus_text is not None:
+                cnv = canvas(self._exp)
+                cnv.text(feedback_stimulus_text)
+                cnv.show()
+            kbd = keyboard(self._exp)
+            while rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0 or \
+                            rc.get_data(rc.Command.GET_THRESHOLD_LEVEL) > 0:
+                kbd.get_key(timeout=polling_intervall)
+
+    def set_thresholds(self, lower, upper):
+        rc.set_force_thresholds(lower=lower, upper=upper)
+
+    def hold_check(self, holding_time=3000,
+                    left_pos=-200, right_pos=200, radius=50,
+                    col_fine='gray',
+                    col_too_low='green',
+                    col_too_strong='red',
+                    n_sensors=2):
+        kbd = keyboard(self._exp)
+        blank = canvas(self._exp)
+        blank.show()
+
+        self.udp.send("hold:test")
+        self.clock.reset_stopwatch()
+        prev_lv = None
+        while True:
+            self.udp.clear_receive_buffer()
+            lv = [rc.get_data(rc.Command.GET_THRESHOLD_LEVEL)]
+            if n_sensors>1:
+                lv.append(rc.get_data(rc.Command.GET_THRESHOLD_LEVEL2))
+            else:
+                lv.append(lv[0]) # just double, if one sensor
+
+            if prev_lv != lv:
+                # level has changes
+                self.clock.reset_stopwatch()
+                prev_lv = lv
+                cnv = canvas(self._exp)
+                for i, pos in enumerate([left_pos, right_pos]):
+                    if lv[i] == WEAK:
+                        cnv.circle(x=pos, y=0, r=radius, fill=True,
+                                   color=col_too_low)
+                    elif lv[i] == STRONG:
+                        cnv.circle(x=pos, y=0, r=radius, fill=True,
+                                   color=col_too_strong)
+                    elif lv[i] == FINE:
+                        cnv.circle(x=pos, y=0, r=radius, fill=True,
+                                   color=col_fine)
+                cnv.show()
+
+            key, _ = kbd.get_key(timeout=0)
+            if (lv == [FINE, FINE] and self.clock.stopwatch_time > holding_time) or\
+                    (key is not None):
+                break
+
+        blank.show()
+
+
+class ExpyClock():
+    """Expyriment-like stopwatch based on Opensesame clock"""
+
+    def __init__(self, opensesame_clock):
+        self._clock = opensesame_clock
+        self.reset_stopwatch()
+
+    @property
+    def time(self):
+        return self._clock.time()
+
+    @property
+    def stopwatch_time(self):
+        return self._clock.time() - self._start
+
+    def reset_stopwatch(self):
+        self._start = self._clock.time()
+
+    def wait(self, waiting_time):
+        return self._clock.sleep(waiting_time)

pyforcedaq/extras/read_force_data.py

@@ -0,0 +1,89 @@
+"""
+Functions to read your force and event data
+"""
+
+__author__ = 'Oliver Lindemann'
+
+import os
+import sys
+import gzip
+from collections import OrderedDict
+import numpy as np
+
+TAG_COMMENTS = "#"
+TAG_UDPDATA  = TAG_COMMENTS + "UDP"
+TAG_DAQEVENTS = TAG_COMMENTS + "T"
+
+def _csv(line):
+    return list(map(lambda x: x.strip(), line.split(",")))
+
+def DataFrameDict(data, varnames):
+    """data frame: Dict of numpy arrays
+
+    does not require Pandas, but can be easily converted to pandas dataframe
+    via pandas.DataFrame(data_frame_dict)
+
+    """
+
+    rtn = OrderedDict()
+    for v in varnames:
+        rtn[v] = []
+
+    for row in data:
+        for v, d in zip(varnames, row):
+            rtn[v].append(d)
+
+    return rtn
+
+
+def data_frame_to_text(data_frame):
+    rtn = ",".join(data_frame.keys())
+    rtn += "\n"
+    for x in np.array(list(data_frame.values())).T:
+        rtn += ",".join(x) + "\n"
+    return rtn
+
+
+def read_raw_data(path):
+    """reading trigger and udp data
+
+    Returns: data, udp_event, daq_events and comments
+
+            data, udp_event, daq_events: DataFrameDict
+            comments: text string
+    """
+
+    daq_events = []
+    udp_events = []
+    comments = ""
+    data = []
+    varnames = None
+    app_dir = os.path.split(sys.argv[0])[0]
+    path = os.path.abspath(os.path.join(app_dir, path))
+
+    if path.endswith("gz"):
+        fl = gzip.open(path, "rt")
+    else:
+        fl = open(path, "rt")
+
+    for ln in fl:
+        if ln.startswith(TAG_COMMENTS):
+            comments += ln
+            if ln.startswith(TAG_UDPDATA + ","):
+                udp_events.append(_csv(ln[len(TAG_UDPDATA) + 1:]))
+            elif ln.startswith(TAG_DAQEVENTS):
+                daq_events.append(_csv(ln[len(TAG_DAQEVENTS) + 1:]))
+        else:
+            # data
+            if varnames is None:
+                # first row contains varnames
+                varnames = _csv(ln)
+            else:
+                data.append(_csv(ln))
+    fl.close()
+
+    return (DataFrameDict(data, varnames),
+            DataFrameDict(udp_events, ["time", "value"]),
+            DataFrameDict(daq_events, ["time", "value"]),
+            comments)
+

pyforcedaq/extras/remote_control.py

@@ -0,0 +1,93 @@
+"""
+import this module to have all relevant classes and function for the remote_control on your remote maschine
+"""
+
+__author__ = 'Oliver Lindemann'
+
+import atexit
+from pickle import dumps, loads
+
+from .._lib.types import Thresholds, bytes_startswith
+from .._lib.types import GUIRemoteControlCommands as Command
+from .._lib.udp_connection import UDPConnection
+
+udp = None
+
+def init_udp_connection():
+    """init udp connecting afterwards udp connection is available via
+        remote_control.udp
+
+    REQUIRED BEFORE USING OTHER FUNCTIONS
+
+    returns udp connection
+    """
+    global udp
+    udp = UDPConnection()
+    return udp
+
+def quit():
+    global udp
+    if isinstance(udp, UDPConnection):
+        udp.send(Command.QUIT)
+    udp = None
+
+
+atexit.register(quit)
+
+def get_data(get_command):
+    """Get data from the recording PC
+    get_commands e.g.
+        Command.GET_FZ or
+        Command.GET_VERSION
+        ....
+    """
+
+    udp.send(get_command)
+    d = udp.receive(1)
+    try:
+        return loads(d[len(Command.VALUE):])
+    except:
+        return None
+
+def poll_event(event_type):
+    """polling response minmax level
+    event_tag:
+        Command.RESPONSE_MINMAX or
+        Command.CHANGED_LEVEL
+        ....
+    """
+    rcv = udp.poll()
+    if rcv is not None and bytes_startswith(rcv, event_type):
+        x = loads(rcv[len(event_type):])
+        return x
+    else:
+        return None
+
+
+def poll_multiple_events(event_type_list):
+    """polling for multiple events
+    e.g.
+        [Command.CHANGED_LEVEL, Command.CHANGED_LEVEL2]
+
+    returns tuple (event_type, event_type_data) or (None, None)
+
+    """
+    rcv = udp.poll()
+    if rcv is not None:
+        for event_type in event_type_list:
+            if bytes_startswith(rcv, event_type):
+                x = loads(rcv[len(event_type):])
+                return (event_type, x)
+    return (None, None)
+
+
+def set_force_thresholds(lower, upper):
+    thr = Thresholds([lower, upper])
+    return udp.send(Command.SET_THRESHOLDS + dumps(thr))
+
+
+def set_level_change_detection(sensor=1):
+    if sensor==2:
+        return udp.send(Command.SET_LEVEL_CHANGE_DETECTION2)
+    else:
+        return udp.send(Command.SET_LEVEL_CHANGE_DETECTION)