pyForceDAQ 2.0.0__py3-none-any.whl

pyforcedaq/_lib/udp_connection.py

@@ -0,0 +1,326 @@
+""" A lan connect class using udp
+"""
+
+__author__ = "Oliver Lindemann <oliver@expyriment.org>"
+__version__ = "0.5"
+
+import atexit
+import logging
+import os
+import socket
+from multiprocessing import Event, Process, Queue
+from subprocess import check_output
+
+from . import timer
+from .polling_time_profile import PollingTimeProfile
+from .process_priority_manager import get_priority
+from .timer import Timer, app_clock, get_time_ms
+from .types import UDPData
+
+
+def get_lan_ip():
+    if os.name == "nt":
+        # Windows
+        return socket.gethostbyname(socket.gethostname())
+    else:
+        # Linux and macOS
+        try:
+            # Try Linux command first
+            rtn = check_output(["hostname", "-I"]).decode().strip()
+            return rtn.split()[0] if rtn else None
+        except:
+            try:
+                # Fallback to macOS command
+                rtn = check_output(["ipconfig", "getifaddr", "en0"]).decode().strip()
+                return rtn if rtn else None
+            except:
+                # Fallback to socket method if both commands fail
+                return socket.gethostbyname(socket.gethostname())
+
+class UDPConnection(object):
+    # DOC document the usage "connecting" "unconnecting"
+    COMMAND_CHAR = b"$"
+    CONNECT = COMMAND_CHAR + b"connect"
+    UNCONNECT = COMMAND_CHAR + b"unconnect"
+    COMMAND_REPLY = COMMAND_CHAR + b"ok"
+    PING = COMMAND_CHAR + b"ping"
+
+    MY_IP = get_lan_ip()
+
+    def __init__(self, udp_port=5005):
+        self.udp_port = udp_port
+
+        self._socket = socket.socket(socket.AF_INET,  # Internet
+                                     socket.SOCK_DGRAM)  # UDP
+        self._socket.bind((UDPConnection.MY_IP, self.udp_port))
+        self._socket.setblocking(False)
+        self.peer_ip = None
+        self.timer = Timer(sync_timer=app_clock) # own timer, because often
+        # used in own process
+
+    @property
+    def my_ip(self):
+        return UDPConnection.MY_IP
+
+    def __str__(self):
+        return "ip: {0} (port: {1}); peer: {2}".format(UDPConnection.MY_IP,
+                                                       self.udp_port, self.peer_ip)
+
+    def receive(self, timeout):
+        """checks for received data and returns it
+
+        In contrast to poll the function keep polling until timeout if no new
+        data are available.
+
+        timeout in seconds
+
+        """
+
+        t = get_time_ms()
+        timeout_ms = int(timeout*1000)
+        while True:
+            rtn = self.poll()
+            if rtn is not None:
+                #print("UDP receive: {0}".format(rtn))
+                return rtn
+            if (get_time_ms() - t) > timeout_ms:
+                return None
+
+    def poll(self):
+        """returns data (bytes) or None if no data found
+        process also commands
+
+        if send is unkown input is ignored
+        """
+
+        try:
+            data, sender = self._socket.recvfrom(1024)
+        except:
+            return None
+
+        # process data
+        if data == UDPConnection.CONNECT:
+            #connection request
+            self.peer_ip = sender[0]
+            if not self.send(UDPConnection.COMMAND_REPLY):
+                self.peer_ip = None
+        elif sender[0] != self.peer_ip:
+            return None  # ignore data
+        elif data == UDPConnection.PING:
+            self.send(UDPConnection.COMMAND_REPLY)
+        elif data == self.UNCONNECT:
+            self.unconnect_peer()
+
+        return data
+
+    def send(self, data, timeout=1.0):
+        """returns if problems or not
+        timeout in seconds (default = 1.0)
+        return False if failed to send
+
+        """
+        timeout_ms = int(timeout*1000)
+        if self.peer_ip is None:
+            return False
+        start = get_time_ms()
+        if isinstance(data, str):
+            data = data.encode() # force to byte
+
+        while get_time_ms() - start < timeout_ms:
+            try:
+                self._socket.sendto(data, (self.peer_ip, self.udp_port))
+                #print("UDP send: {0}".format(data))
+                return True
+            except:
+                pass
+        return False
+
+    def connect_peer(self, peer_ip, timeout=1.0):
+
+        self.unconnect_peer()
+        self.peer_ip = peer_ip
+        if self.send(UDPConnection.CONNECT, timeout=timeout) and \
+                self.wait_input(UDPConnection.COMMAND_REPLY, duration=timeout):
+            return True
+        self.peer_ip = None
+        return False
+
+    def wait_input(self, input_string, duration=1.0):
+        """poll the connection and waits for a specific input"""
+        start = get_time_ms()
+        duration_ms = int(duration*1000)
+        while get_time_ms() - start < duration_ms:
+            in_ = self.poll()
+            if in_ == input_string:
+                return True
+        return False
+
+    def unconnect_peer(self, timeout=1.0):
+        self.send(UDPConnection.UNCONNECT, timeout=timeout)
+        self.peer_ip = None
+
+    @property
+    def is_connected(self):
+        return self.peer_ip is not None
+
+    def ping(self, timeout=0.5):
+        """returns boolean if succeeded and ping time in ms"""
+
+        if self.peer_ip == None:
+            return False, None
+        start = get_time_ms()
+        if self.send(UDPConnection.PING, timeout=timeout) and \
+                self.wait_input(UDPConnection.COMMAND_REPLY, duration=timeout):
+            return True, get_time_ms() - start
+        return False, None
+
+    def clear_receive_buffer(self):
+        data = ""
+        while data is not None:
+            data = self.poll()
+
+    def poll_last_data(self):
+        """polls all data and returns only the last one
+        return None if not data found"""
+        rtn = None
+        tmp = self.poll()
+        while tmp is not None:
+            rtn = tmp
+            tmp = self.poll()
+        return rtn
+
+
+class UDPConnectionProcess(Process):
+    """UDPConnectionProcess polls and writes to a data queue.
+
+    Example::
+
+        # Server that prints each input and echos it to the client
+        # that is currently connected
+
+        from udp_connection import UDPConnectionProcess, Queue
+
+        receive_queue = Queue()
+        udp_p = UDPConnectionProcess(receive_queue=receive_queue)
+        udp_p.start()
+        udp_p.event_polling.set() # start polling
+
+        while True:
+            data = receive_queue.get()
+            print(data)
+            if data is not None:
+                udp_p.send_queue.put(data.string)
+
+    Example::
+
+        # connecting to a server
+    """        # DOC
+
+    def __init__(self, event_trigger = (),
+                 event_ignore_tag = None):
+        """Initialize UDPConnectionProcess
+
+        Parameters
+        ----------
+        receive_queue: multiprocessing.Queue
+            the queue to which the received data should be put
+
+        peer_ip : string
+            the IP of the peer to which the connection should be established
+
+        sync_clock : Timer
+            the internal clock for timestamps will synchronized with this clock
+
+        event_trigger: multiprocessing.Event() (or list of..)
+            event trigger(s) to be set. If Udp event is received and it is not a
+            command to set this event (typical of sensor recording processes).
+
+        event_ignore_tag:
+            udp data that start with this tag will be ignored for event triggering
+
+        """ # DOC
+
+        super(UDPConnectionProcess, self).__init__()
+
+        self.receive_queue = Queue()
+        self.send_queue = Queue()
+        self.event_is_connected = Event()
+        self._event_quit_request = Event()
+        self._event_is_polling = Event()
+        self._event_ignore_tag = event_ignore_tag
+
+        if isinstance(event_trigger, type(Event)  ):
+            event_trigger = (event_trigger)
+        try:
+            self._event_trigger = tuple(event_trigger)
+        except:
+            self._event_trigger = ()
+
+        atexit.register(self.quit)
+
+    @property
+    def my_ip(self):
+        return UDPConnection.MY_IP
+
+    def quit(self):
+        self._event_quit_request.set()
+        if self.is_alive():
+            self.join()
+
+    def pause(self):
+        self._event_is_polling.clear()
+
+    def start_polling(self):
+        self._event_is_polling.set()
+
+    def run(self):
+        udp_connection = UDPConnection(udp_port=5005)
+        self.start_polling()
+
+        ptp = PollingTimeProfile()
+        prev_event_polling = None
+
+        while not self._event_quit_request.is_set():
+
+            if prev_event_polling != self._event_is_polling.is_set():
+                # event pooling changed
+                prev_event_polling = self._event_is_polling.is_set()
+                if prev_event_polling:
+                    logging.warning("UDP start, pid {}, priority {}".format(
+                            self.pid, get_priority(self.pid)))
+                else:
+                    logging.warning("UDP stop")
+                    ptp.stop()
+
+            if not self._event_is_polling.is_set():
+                self._event_is_polling.wait(timeout=0.1)
+            else:
+                data = udp_connection.poll()
+                t = udp_connection.timer.time
+                ptp.update(t)
+                if data is not None:
+                    d = UDPData(string=data, time=t)
+                    self.receive_queue.put(d)
+                    if self._event_ignore_tag is not None and \
+                            not d.startswith(self._event_ignore_tag):
+                        for ev in self._event_trigger:
+                            # set all connected software trigger
+                            ev.set() ## FIXME LSL trigger
+                try:
+                    udp_connection.send(self.send_queue.get_nowait())
+                except:
+                    pass
+
+                # has connection changed?
+                if self.event_is_connected.is_set() != udp_connection.is_connected:
+                    if udp_connection.is_connected:
+                        self.event_is_connected.set()
+                    else:
+                        self.event_is_connected.clear()
+
+                if not udp_connection.is_connected:
+                    timer.wait(200)
+
+        udp_connection.unconnect_peer()
+
+        logging.warning("UDP quit, {}".format(ptp.get_profile_str()))

pyforcedaq/daq/__init__.py

@@ -0,0 +1,19 @@
+__author__ = "Oliver Lindemann"
+__version__ = "0.4"
+
+from .. import USE_MOCK_SENSOR
+from ._pyATIDAQ import ATI_CDLL
+from .config import DAQConfiguration
+
+if USE_MOCK_SENSOR:
+    print("Using mock sensor instead.")
+    from ._mock_sensor import DAQReadAnalog
+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):
+        print("Warning: PyDAQmx or nidaqmx not found. Using mock sensor instead.")
+        from ._mock_sensor import DAQReadAnalog
+

pyforcedaq/daq/_daq_read_Analog_pydaqmx.py

@@ -0,0 +1,114 @@
+"""Module to read data analog data from NI-DAQ device
+
+A simple high-level wrapper for NI-DAQmx functions
+
+Requires: PyDAQmx, Numpy
+
+See COPYING file distributed along with the pyForceDAQ copyright and license terms.
+"""
+
+__author__ = 'Oliver Lindemann'
+
+import ctypes as ct
+
+import numpy as np
+import PyDAQmx
+
+from . import DAQConfiguration
+
+
+class DAQReadAnalog(PyDAQmx.Task):
+
+    NUM_SAMPS_PER_CHAN = ct.c_int32(1)
+    TIMEOUT = ct.c_longdouble(1.0)  # one second
+    NI_DAQ_BUFFER_SIZE = 1000
+    DAQ_TYPE = "PyDAQmx"
+
+    def __init__(self, configuration: DAQConfiguration, read_array_size_in_samples: int ):
+        """ DOC
+        read_array_size_in_samples for ReadAnalogF64 call
+
+        """
+
+        # print('init')
+        PyDAQmx.Task.__init__(self)
+        # CreateAIVoltageChan
+        self.CreateAIVoltageChan(configuration.physicalChannel,
+                                 # physicalChannel
+                                 "",  # nameToAssignToChannel,
+                                 PyDAQmx.DAQmx_Val_Diff,  # terminalConfig
+                                 ct.c_double(configuration.minVal),
+                                 ct.c_double(configuration.maxVal),
+                                 # min max Val
+                                 PyDAQmx.DAQmx_Val_Volts,  # units
+                                 None  # customScaleName
+                                 )
+
+        # CfgSampClkTiming
+        self.CfgSampClkTiming("",  # source
+                              ct.c_double(float(configuration.rate)),  # rate
+                              PyDAQmx.DAQmx_Val_Rising,  # activeEdge
+                              PyDAQmx.DAQmx_Val_ContSamps,  # sampleMode
+                              ct.c_uint64(DAQReadAnalog.NI_DAQ_BUFFER_SIZE)
+                              # sampsPerChanToAcquire, i.e. buffer size
+                              )
+
+        self._task_is_started = False
+        self.read_array_size_in_samples = read_array_size_in_samples
+
+    @property
+    def is_acquiring_data(self):
+        return self._task_is_started
+
+    def start_data_acquisition(self):
+        """Start data acquisition of the NI device
+        call always before polling
+
+        """
+
+        if not self._task_is_started:
+            self.StartTask()
+            self._task_is_started = True
+
+    def stop_data_acquisition(self):
+        """ Stop data acquisition of the NI device
+        """
+
+        if self._task_is_started:
+            self.StopTask()
+            self._task_is_started = False
+
+    def read_analog(self):
+        """Polling data
+
+        Reading data from NI device
+
+        Parameter
+        ---------
+        array_size_in_samps : int
+            the array size in number of samples
+
+        Returns
+        -------
+        read_buffer : numpy array
+            the read data
+        read_samples : int
+            the number of read samples
+
+        """
+
+        # fill in data
+        read_samples = ct.c_int32()
+        read_buffer = np.zeros((self.read_array_size_in_samples,),
+                               dtype=np.float64)
+
+        error = self.ReadAnalogF64(self.NUM_SAMPS_PER_CHAN,
+                                   self.TIMEOUT,
+                                   PyDAQmx.DAQmx_Val_GroupByScanNumber,
+                                   # fillMode
+                                   read_buffer,
+                                   ct.c_uint32(self.read_array_size_in_samples),
+                                   ct.byref(read_samples),
+                                   None)
+
+        return read_buffer, read_samples.value

pyforcedaq/daq/_daq_read_analog_nidaqmx.py

@@ -0,0 +1,84 @@
+import nidaqmx
+import numpy as np
+from nidaqmx import constants as nidaq_consts
+
+from . import DAQConfiguration
+
+
+class DAQReadAnalog(nidaqmx.Task):
+
+    NUM_SAMPS_PER_CHAN = nidaq_consts.READ_ALL_AVAILABLE # or 1 FIXME?
+    TIMEOUT = 1.0
+    DAQ_TYPE = "nidaqmx"
+
+    def __init__(self, configuration: DAQConfiguration, read_array_size_in_samples: int):
+        """ DOC
+        read_array_size_in_samples for ReadAnalogF64 call
+
+        """
+
+        nidaqmx.Task.__init__(self)
+
+        # CreateAIVoltageChan
+        self.ai_channels.add_ai_voltage_chan(physical_channel=configuration.physicalChannel,
+                            terminal_config=nidaq_consts.TerminalConfiguration.DIFF,
+                            min_val=configuration.minVal,
+                            max_val=configuration.maxVal,
+                            units=nidaq_consts.VoltageUnits.VOLTS
+                            )
+        print('added channels')
+        #CfgSampClkTiming
+        self.timing.cfg_samp_clk_timing(rate=float(configuration.rate),
+                            active_edge=nidaq_consts.Edge.RISING,
+                            sample_mode=nidaq_consts.AcquisitionType.CONTINUOUS
+                            )
+        print('devices')
+        print(nidaqmx.Task.devices)
+        self._task_is_started = False
+        self.read_array_size_in_samples = read_array_size_in_samples
+
+    @property
+    def is_acquiring_data(self):
+        return self._task_is_started
+
+    def start_data_acquisition(self):
+        """Start data acquisition of the NI device
+        call always before polling
+
+        """
+
+        if not self._task_is_started:
+            self.start()
+            self._task_is_started = True
+
+    def stop_data_acquisition(self):
+        """ Stop data acquisition of the NI device
+        """
+
+        if self._task_is_started:
+            self.stop()
+            self._task_is_started = False
+
+    def read_analog(self):
+        """Polling data
+
+        Reading data from NI device
+
+        Parameter
+        ---------
+        array_size_in_samps : int
+            the array size in number of samples
+
+        Returns
+        -------
+        read_buffer : numpy array
+            the read data
+        read_samples : int
+            the number of read samples
+
+        """
+
+        #fill in data
+        data = self.read(self.NUM_SAMPS_PER_CHAN, self.TIMEOUT)
+        np_data = np.reshape(np.array(data),(-1,))
+        return np_data, len(np_data)

pyforcedaq/daq/_mock_sensor.py

@@ -0,0 +1,80 @@
+__author__ = 'Oliver Lindemann'
+
+import logging
+
+import numpy as np
+
+from .._lib.timer import Timer
+
+
+class DAQReadAnalog(object):
+    NUM_SAMPS_PER_CHAN =  1
+    TIMEOUT = 1.0
+    NI_DAQ_BUFFER_SIZE = 1000
+    DAQ_TYPE = "mock_sensor"
+
+    def __init__(self, configuration=None,
+                 read_array_size_in_samples=None):
+        self.read_array_size_in_samples = read_array_size_in_samples
+        self._task_is_started = False
+        self._last_time = 0
+        self._sample_cnt = 0
+        self._simulation_timer = Timer()
+        txt = "Using mock sensor: Maybe PyDAQmx or nidaqmx is not  installed"
+        logging.warning(txt)
+        print(txt)
+
+
+    @property
+    def is_acquiring_data(self):
+        return self._task_is_started
+
+    def start_data_acquisition(self):
+        """Start data acquisition of the NI device
+        call always before polling
+
+        """
+
+        if not self._task_is_started:
+            self._task_is_started = True
+            self._simulation_timer = Timer() #reset
+            self._sample_cnt = 0
+
+    def stop_data_acquisition(self):
+        """ Stop data acquisition of the NI device
+        """
+
+        if self._task_is_started:
+            self._task_is_started = False
+
+    def read_analog(self):
+        """Reading data
+
+        Reading data from NI device
+
+        Parameter
+        ---------
+        array_size_in_samps : int
+            the array size in number of samples
+
+        Returns
+        -------
+        read_buffer : numpy array
+            the read data
+        read_samples : int
+            the number of read samples
+
+        """
+
+        # fill in data
+        if not self._task_is_started:
+            return None, None
+
+        n_new_samples = self._simulation_timer.time - self._sample_cnt
+        while n_new_samples <= 0:
+            n_new_samples = self._simulation_timer.time - self._sample_cnt
+
+        self._sample_cnt += 1
+        x = self._sample_cnt / 2000
+        y = 10 + np.array((np.sin(x/2), np.cos(x/5), np.sin(x)))*10
+        return np.append(y, np.array((0, 0 , 0, 0, 0))), 1