pyForceDAQ 2.0.0__py3-none-any.whl

pyforcedaq/daq/_pyATIDAQ.py

@@ -0,0 +1,306 @@
+"""pyATIDAQ: Python wrapper for atidaq c library
+
+Notes
+-----
+see ftconfig.h & ftsharedrt.h for details
+
+See COPYING file distributed along with the pyForceDAQ copyright and license terms.
+"""
+
+__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
+DISPLACEMENT_VECTOR = c_float * 8
+UNITS = c_char_p
+MAX_AXES = 6
+MAX_GAUGES = 8
+
+
+# calibration information required for F/T conversions
+class RTCoefs(Structure):
+    _fields_ = [
+        ('NumChannels', c_ushort),
+        ('NumAxes', c_ushort),
+        ('working_matrix', (c_float * MAX_AXES) * MAX_GAUGES),
+        ('bias_slopes', c_float * MAX_GAUGES),
+        ('gain_slopes', c_float * MAX_GAUGES),
+        ('thermistor', c_float),
+        ('bias_vector', c_float * (MAX_GAUGES + 1)),
+        ('TCbias_vector', c_float * MAX_GAUGES)]
+
+
+class Transform(Structure):
+    _fields_ = [
+        ('TT', c_float * 6),  # displacement/rotation vector dx, dy, dz, rx, ry, r
+        ('DistUnits', UNITS),  # units of dx, dy, dz
+        ('AngleUnits', UNITS)]  # units of rx, ry, rz
+
+
+class Configuration(Structure):
+    _fields_ = [
+        ('ForceUnits', UNITS),  # force units of output
+        ('TorqueUnits', UNITS),  # torque units of output
+        ('UserTransform', Transform),  # coordinate system transform set by user
+        ('TempCompEnabled', c_bool)]  # is temperature compensation enabled?
+
+
+class Calibration(Structure):
+    _fields_ = [
+        ('BasicMatrix', (c_float * MAX_AXES) * MAX_GAUGES),  # non-usable matrix; use rt.working_matrix for calculations
+        ('ForceUnits', UNITS),  # force units of basic matrix, as read from file; constant
+        ('TorqueUnits', UNITS),  # torque units of basic matrix, as read from file; constant
+        ('TempCompAvailable', c_bool),  # does this calibration have optional temperature compensation?
+        ('BasicTransform', Transform),  # built-in coordinate transform; for internal use
+        ('MaxLoads', c_float * MAX_AXES),  # maximum loads of each axis, in units above
+        ('AxisNames', c_char_p * MAX_AXES),  # names of each axis
+        ('Serial', c_char_p),  # serial number of transducer (such as "FT4566")
+        ('BodyStyle', c_char_p),  # transducer's body style (such as "Delta")
+        ('PartNumber', c_char_p),  # calibration part number (such as "US-600-3600")
+        ('Family', c_char_p),  # family of transducer (typ. "DAQ")
+        ('CalDate', c_char_p),  # date of calibration
+        ('cfg', Configuration),  # struct containing configurable parameters
+        ('rt', RTCoefs)]  # struct containing coefficients used in realtime calculations
+
+
+calibration_p = POINTER(Calibration)
+
+
+class ATI_CDLL(object):
+
+    def __init__(self):
+
+        if platform.startswith('linux'):
+            lib_path = "/usr/lib/atidaq.so"
+        elif platform == 'win32':
+            lib_path = "C:\\Windows\\System\\atidaq.dll"
+        else:
+            raise RuntimeError("Your plattform is not supported")
+
+        self.cdll = CDLL(lib_path)
+
+        self.cdll.createCalibration.argtype = [c_char_p, c_ushort]
+        self.cdll.createCalibration.restype = calibration_p
+
+        self.cdll.destroyCalibration.argtype = [calibration_p]
+        self.cdll.destroyCalibration.restype = None
+
+        self.cdll.SetToolTransform.argtype = [calibration_p, DISPLACEMENT_VECTOR,
+                                c_char_p, c_char_p]
+        self.cdll.SetToolTransform.restype = c_short
+
+        self.cdll.SetForceUnits.argtype = [calibration_p, c_char_p]
+        self.cdll.SetForceUnits.restype = c_short
+
+        self.cdll.SetTorqueUnits.argtype = [calibration_p, c_char_p]
+        self.cdll.SetTorqueUnits.restype = c_short
+
+        self.cdll.SetTempComp.argtype = [calibration_p, c_char_p]
+        self.cdll.SetTempComp.restype = c_short
+
+        self.cdll.Bias.argtype = [calibration_p, POINTER(c_float)]
+        self.cdll.Bias.restype = None
+
+        self.cdll.ConvertToFT.argtype = [calibration_p, POINTER(c_float),
+                                POINTER(c_float)]
+        self.cdll.ConvertToFT.restype = None
+
+        self.cdll.printCalInfo.argtype = [calibration_p]
+        self.cdll.printCalInfo.restype = None
+
+        self._calibration = None
+
+    def __del__(self):
+        self.destroyCalibration()
+
+    def calibration(self):
+        """The current calibration
+        Returns
+           cal: POINTER(Calibration), calibration pointer
+                initialized Calibration struct
+
+        """
+        return self._calibration
+
+    def createCalibration(self, CalFilePath, index):
+        """ Loads calibration info for a transducer into a new Calibration struct
+        Parameters:
+           CalFilePath: c_char_p
+                the name and path of the calibration file
+           index: c_ushort
+                the number of the calibration within the file (usually 1)
+           NULL: Could not load the desired calibration.
+         Notes: For each Calibration object initialized by this function,
+                destroyCalibration must be called for cleanup.
+        """
+
+        self._calibration = self.cdll.createCalibration(CalFilePath.encode(), index)
+        if self._calibration == 0:
+            raise RuntimeError("Specified calibration could not be loaded.")
+
+
+    def destroyCalibration(self):
+        """Frees memory allocated for Calibration struct by a successful
+         call to createCalibration.  Must be called when Calibration
+         struct is no longer needed.
+        """
+
+        return self.cdll.destroyCalibration(self._calibration)
+
+    def setToolTransform(self, Vector, DistUnits, AngleUnits):
+        """Performs a 6-axis translation/rotation on the transducer's coordinate system.
+         Parameters:
+           Vector: array of float
+                displacements and rotations in the order Dx, Dy, Dz, Rx, Ry, Rz
+           DistUnits: c_char_p
+                units of Dx, Dy, Dz
+           AngleUnits: c_char_p
+                units of Rx, Ry, Rz
+        """
+
+        error = self.cdll.SetToolTransform(self._calibration, DISPLACEMENT_VECTOR(*Vector),
+                                           DistUnits.encode(),
+                                           AngleUnits.encode())
+        if error:
+            if error == 1:
+                raise RuntimeError("Invalid Calibration struct.")
+            elif error == 2:
+                raise RuntimeError("Invalid distance units.")
+            elif error == 3:
+                raise RuntimeError("Invalid angle units.")
+            else:
+                raise RuntimeError("Unknown error.")
+
+
+
+    def setForceUnits(self, NewUnits):
+        """Sets the units of force output
+         Parameters:
+           NewUnits: c_char_p
+                units for force output
+        		("lb","klb","N","kN","g","kg")
+        """
+
+        error = self.cdll.SetForceUnits(self._calibration,
+                                        NewUnits.encode())
+        if error:
+            if error == 1:
+                raise RuntimeError("Invalid Calibration struct.")
+            elif error == 2:
+                raise RuntimeError("Invalid force units.")
+            else:
+                raise RuntimeError("Unknown error.")
+
+
+    def setTorqueUnits(self, NewUnits):
+        """Sets the units of torque output
+         Parameters:
+           NewUnits: c_char_p
+                units for torque output
+        		("in-lb","ft-lb","N-m","N-mm","kg-cm")
+        """
+        error = self.cdll.SetTorqueUnits(self._calibration,
+                                         NewUnits.encode())
+        if error:
+            if error == 1:
+                raise RuntimeError("Invalid Calibration struct.")
+            elif error == 2:
+                raise RuntimeError("Invalid torque units.")
+            else:
+                raise RuntimeError("Unknown error.")
+
+
+    def setTempComp(self, TCEnabled):
+        """Enables or disables temperature compensation, if available
+         Parameters:
+           TCEnabled: c_char_p
+                      0 = temperature compensation off
+                      1 = temperature compensation on
+        """
+
+        error = self.cdll.SetTempComp(self._calibration,
+                                      TCEnabled.encode())
+        if error:
+            if error == 1:
+                raise RuntimeError("Invalid Calibration struct.")
+            elif error == 2:
+                raise RuntimeError("Not available on this transducer system")
+            else:
+                raise RuntimeError("Unknown error.")
+
+    def bias(self, voltages):
+        """Stores a voltage reading to be subtracted from subsequent readings,
+         effectively "zeroing" the transducer output to remove tooling weight, etc.
+         Parameters:
+           voltages: array of float
+                array of voltages acquired by DAQ system
+        """
+
+        return self.cdll.Bias(self._calibration, VOLTAGE_SAMPLE_TYPE(*voltages))
+
+    def convertToFT(self, voltages, reverse_parameters=[]):
+        """Converts an array of voltages into forces and torques and
+         returns them in result
+         Parameters:
+           voltages: array of float
+                array of voltages acquired by DAQ system
+            reverse_parameters: array of integer
+                list of ids of parameter that should be reversed due to problems calibration with
+                    the calibration
+         Returns:
+            array of force-torque values (typ. 6 elements)
+        """
+        ft_array = FT_SAMPLE_TYPE()
+        self.cdll.ConvertToFT(self._calibration, VOLTAGE_SAMPLE_TYPE(*voltages),
+                              byref(ft_array))
+        rtn = list(map(lambda x: x, ft_array))  # convert ctype array to python
+        # array
+        for x in reverse_parameters:
+            rtn[x] = -1*rtn[x]
+        return rtn
+
+    def printCalInfo(self):
+        """print Calibration info on the console
+        """
+
+        return self.cdll.printCalInfo(self._calibration)
+
+def print_calibration_info(calibration_file):
+    """convenient function to print calibration file infos"""
+    atidaq = ATI_CDLL()
+    index = c_short(1)
+    calibration = atidaq.createCalibration(calibration_file, index)
+    atidaq.printCalInfo(calibration)
+    atidaq.destroyCalibration(calibration)
+
+
+if __name__ == "__main__":
+    # test module
+
+    # FT_sensor1.cal
+    # Bias reading:
+    #   0.265100 -0.017700 -0.038400 -0.042700 -0.189100  0.137300 -3.242300
+    #   Measurement:
+    #   -3.286300  0.387500 -3.487700  0.404300 -3.934100  0.547400 -3.210600
+    #   Result:
+    #   -0.065867  0.123803 111.156731  0.039974  0.040417  0.079049
+
+    #filename = raw_input("Calibration file: ")
+    filename = find_calibration_file("calibration", "FT30436")
+    atidaq = ATI_CDLL()
+    # get calibration
+    index = c_short(1)
+    atidaq.createCalibration(filename, index)
+    atidaq.setForceUnits("N")
+    atidaq.setTorqueUnits("N-m")
+
+    atidaq.bias([0.2651, -0.0177, -0.0384, -0.0427, -0.1891, 0.1373, -3.2423])
+    atidaq.printCalInfo()
+    print("\nConverting")
+    print(atidaq.convertToFT([-3.2863, 0.3875, -3.4877, 0.4043, -3.9341, 0.5474, -3.2106]))

pyforcedaq/daq/config.py

@@ -0,0 +1,13 @@
+class DAQConfiguration(object):
+    """Settings required for NI-DAQ"""
+    def __init__(self, device_name: str, channels: str = "ai0:7",
+                 rate: int = 1000, minVal: float = -10,  maxVal: float = 10):
+        self.device_name = device_name
+        self.channels = channels
+        self.rate = rate
+        self.minVal = minVal
+        self.maxVal = maxVal
+
+    @property
+    def physicalChannel(self):
+        return "{0}/{1}".format(self.device_name, self.channels)

pyforcedaq/extras/convert.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+
+"""
+Functions to convert force data
+
+This module can be also executed.
+"""
+
+__author__ = 'Oliver Lindemann'
+
+import os
+import sys
+import gzip
+import numpy as np
+from .read_force_data import read_raw_data, data_frame_to_text
+
+PAUSE_CRITERION = 500
+MSEC_PER_SAMPLES = 1
+REF_SAMPLE_PROBE = 1000
+MIN_DELAY_ENDSTREAM = 2
+CONVERTED_SUFFIX = ".conv.csv.gz"
+CONVERTED_SUBFOLDER = "converted"
+
+def _periods_from_daq_events(daq_events):
+
+    periods = {}
+    started = None
+    sensor_id = None
+    evt = np.array(daq_events["value"])
+    times = np.array(daq_events["time"]).astype(int)
+    idx = np.argsort(times)
+
+    for t, v in zip(times[idx], evt[idx]):
+        try:
+            sensor_id = int(v.split(":")[1])
+        except:
+            sensor_id = None
+
+        if sensor_id not in periods:
+            periods[sensor_id] = []
+
+        if v.startswith("started"):
+            if started is None:
+                started = t
+            else:
+                periods[sensor_id].append((started, None))
+                started = None
+        elif v.startswith("pause"):
+            periods[sensor_id].append((started, t))
+            started = None
+
+    # sort remaining
+    if started is not None:
+        periods[sensor_id].append((started, None))
+
+    return periods
+
+def _pauses_idx_from_timeline(time, pause_criterion):
+    pauses_idx = np.where(np.diff(time) > pause_criterion)[0]
+    last_pause = -1
+    rtn = []
+    for idx in np.append(pauses_idx, len(time)-1):
+        rtn.append((last_pause+1, idx))
+        last_pause = idx
+    return rtn
+
+def _most_frequent_value(values):
+    (v, cnt) = np.unique(values, return_counts=True)
+    idx = np.argmax(cnt)
+    return v[idx]
+
+def print_histogram(values):
+    (v, cnt) = np.unique(values, return_counts=True)
+    for a,b in zip(v,cnt):
+        print("{} -- {}".format(a,b))
+
+
+def _end_stream_sample(timestamps, min_delay=MIN_DELAY_ENDSTREAM):
+    """finds end of the data stream, that is, sample before next long waiting
+    sample or returns None if no end can be detected"""
+
+    next_t_diffs = np.diff(timestamps)
+    try:
+        return np.where(next_t_diffs >= min_delay)[0][0] #+1-1
+    except:
+        return None
+
+
+def _linear_timeline_matched_by_single_reference_sample(irregular_timeline,
+                                                        id_ref_sample, msec_per_sample):
+    """match timeline that differences between the two is minimal
+    new times can not be after irregular times
+    """
+    t_ref = irregular_timeline[id_ref_sample]
+    t_first = t_ref - (id_ref_sample*msec_per_sample)
+    t_last = t_first + ((len(irregular_timeline) - 1) * msec_per_sample)
+    return np.arange(t_first, t_last + msec_per_sample, step=msec_per_sample)
+
+
+def _timeline_matched_by_delay_chunked_samples(times, msec_per_sample):
+
+    rtn = np.empty(len(times))*np.NaN
+    p = 0
+    while p<len(times):
+        next_ref_sample = _end_stream_sample(times[p:])
+        if next_ref_sample is not None:
+            ref_time = times[p+next_ref_sample]
+            rtn[p:(p+next_ref_sample+1)] = np.arange(
+                                  start = ref_time - (next_ref_sample*msec_per_sample),
+                                  stop  = ref_time + msec_per_sample,
+                                  step  = msec_per_sample)
+            p = p + next_ref_sample + 1
+
+        else:
+            # no further refence samples
+            rtn[p:] = times[p:]
+            break
+
+    return rtn
+
+class Method(object):
+
+    types = {1: "single reference sample (forced linearity)",
+             2: "multiple delayed chunked samples (no linearity assumed)"}
+
+    def __init__(self, id):
+        if id not in Method.types:
+            raise RuntimeError("Unkown resampling method")
+        self.id = id
+
+    @property
+    def description(self):
+        return Method.types[self.id]
+
+    @staticmethod
+    def get_method_from_description(description):
+        for id, desc in Method.types.items():
+            if desc == description:
+                return Method(id)
+        return None
+
+
+def _adjusted_timestamps(timestamps, pauses_idx, evt_periods, method):
+    """
+        method=Method(1): _linear_timeline_matched_by_single_reference_sample
+        method=Method(2): _timeline_matched_by_delay_chunked_samples
+    """
+
+    # adapting timestamps
+    rtn = np.empty(len(timestamps))*np.NaN
+    period_counter = 0
+    for idx, evt_per in zip(pauses_idx, evt_periods):
+        # loop over periods
+
+        # logging
+        period_counter += 1
+        n_samples = idx[1] - idx[0] + 1
+        if evt_per[1]: # end time
+            sample_diff  = n_samples - (1+(evt_per[1]-evt_per[0])//MSEC_PER_SAMPLES)
+            if sample_diff!=0:
+                print("Period {}: Sample difference of {}".format(
+                    period_counter, sample_diff))
+        else:
+            print("Period {}: No pause sampling time.".format(period_counter))
+
+        #convert times
+        times = timestamps[idx[0]:idx[1] + 1]
+        if method.id==1:
+            # match refe samples
+            next_ref = _end_stream_sample(times[REF_SAMPLE_PROBE:(REF_SAMPLE_PROBE + 1000)])
+            if next_ref is None:
+                next_ref = 0
+            newtimes = _linear_timeline_matched_by_single_reference_sample(
+                        times, id_ref_sample=REF_SAMPLE_PROBE + next_ref,
+                        msec_per_sample=MSEC_PER_SAMPLES)
+        elif method.id==2:
+            # using delays
+            newtimes = _timeline_matched_by_delay_chunked_samples(times,
+                                                                  msec_per_sample=MSEC_PER_SAMPLES)
+        else:
+            newtimes = times
+
+        rtn[idx[0]:idx[1] + 1] = newtimes
+
+    return rtn.astype(int)
+
+
+def converted_filename(flname):
+    """returns path and filename of the converted data file"""
+    if flname.endswith(".gz"):
+        tmp = flname[:-7]
+    else:
+        tmp = flname[:-4]
+
+    path, new_filename = os.path.split(tmp)
+    converted_path = os.path.join(path, CONVERTED_SUBFOLDER)
+    return converted_path, new_filename + CONVERTED_SUFFIX
+
+def convert_raw_data(filepath, method, save_time_adjustments=False,
+                     keep_delay_variable=False):
+    """preprocessing raw pyForceData:
+
+    """
+    # todo only one sensor
+    assert(isinstance(method, Method))
+
+    filepath = os.path.join(os.path.split(sys.argv[0])[0], filepath)
+    print("Converting {}".format(filepath))
+    print("Method: {}".format(method.description))
+
+    data, udp_event, daq_events, comments = read_raw_data(filepath)
+    print("{} samples".format(len(data["time"])))
+
+    sensor_id = 1
+    if not keep_delay_variable:
+        data.pop("delay", None)
+
+    timestamps = np.array(data["time"]).astype(int)
+
+    #pauses
+    pauses_idx = _pauses_idx_from_timeline(timestamps, pause_criterion=PAUSE_CRITERION)
+    evt_periods = _periods_from_daq_events(daq_events)
+
+    if len(pauses_idx) != len(evt_periods[sensor_id]):
+        raise RuntimeError("Pauses in DAQ events do not match recording pauses")
+    else:
+        data["time"] = _adjusted_timestamps(timestamps=timestamps,
+                                            pauses_idx=pauses_idx,
+                                            evt_periods=evt_periods[
+                                            sensor_id],
+                                            method=method)
+
+    if save_time_adjustments:
+        data["time_adjustment"] = timestamps-data["time"]
+        #print("Time difference historgram")
+        #print_histogram(data["time_adjustment"])
+
+    #save
+    folder, new_filename = converted_filename(filepath)
+    try:
+        os.makedirs(folder)
+    except:
+        pass
+    new_filename = os.path.join(folder, new_filename)
+
+    with gzip.open(new_filename, "wt") as fl:
+        fl.write(comments.strip() + "\n")
+        fl.write(data_frame_to_text(data))
+
+def get_all_data_files(folder):
+    rtn = []
+    for flname in os.listdir(folder):
+        if (flname.endswith(".csv") or flname.endswith(".csv.gz")) and not \
+                flname.endswith(CONVERTED_SUFFIX):
+            flname = os.path.join(folder, flname)
+            rtn.append(flname)
+    return rtn
+
+def get_all_unconverted_data_files(folder):
+    rtn = []
+    files = get_all_data_files(folder)
+
+
+    try:  # make subfolder
+        c_path, _ = converted_filename(files[0])
+        converted_files = os.listdir(c_path)
+    except:
+        converted_files = []
+
+    for flname in files:
+        _, c_flname = converted_filename(flname)
+        if c_flname not in converted_files:
+            rtn.append(flname)
+    return rtn
+