python-microscopy 26.7.9__cp313-cp313-macosx_26_0_arm64.whl

PYME/Acquire/Hardware/AAOptoelectronics/MDS.py

@@ -0,0 +1,175 @@
+#!/usr/bin/python
+
+###############
+# MPBCWLaser.py
+#
+# Copyright David Baddeley, 2012
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+################
+# import serial
+# import time
+# import threading
+import re
+from PYME.Acquire.Hardware.aotf import AOTF
+import serial
+import threading
+import logging
+logger = logging.getLogger(__name__)
+
+
+class AAOptoMDS(AOTF):
+    """
+    Our device doesn't tolerate many port openings/closings and requires its buffer to be cleared regularly. Could be
+    because we connect to it through an external USB hub. As a result we keep the serial ports open rather than using
+    context managers.
+    """
+    def __init__(self, calibrations, com_port='COM6', name='AAOptoMDS', n_chans=8, serial_timeout=1, baud_rate=57600):
+        """
+        Parameters
+        ----------
+        calibrations: dict
+            see PYME.Acquire.Hardware.aotf.AOTF base class. Note that the key's (corresponding to each channel) should
+            be zero-indexed, this class will handle converting to one-indexed channels to match the MDS API.
+        com_port: str
+            Name of the com port to connect to, e.g. 'COM14'.
+        name: str
+            Name of the device
+        n_chans: int
+            Number of channels, typically 4 or 8.
+        serial_timeout: float
+            Timeout to be used in all serial reads
+        """
+        AOTF.__init__(self, name, calibrations, n_chans)
+
+        # initialize serial
+        self.timeout = serial_timeout
+        # initialize and configure the serial port without opening it
+        self.com_port = serial.Serial(com_port, baud_rate, timeout=serial_timeout)
+        self.lock = threading.Lock()
+        self.is_on = True
+        # set to internal control mode, grab a couple extra lines to give the unit time to write before clearing buffer
+        logger.debug('Setting AOTF to internal control mode')
+        self.query(b'I0\r\n', lines_expected=3)
+        # Grab the initial properties
+        logger.debug('Getting MDS status')
+        self.GetStatus()
+        logger.debug('Disabling any active AOTF channels')
+        [(self.Disable(channel), self.SetPower(0, channel)) if self.channel_enabled[channel] else None for channel in range(self.n_chans)]
+
+    def query(self, command, lines_expected=1):
+        """
+        Send serial command and return a set number of reply lines from the device before clearing the device outputs
+
+        Parameters
+        ----------
+        command: bytes
+            Command to send to the device. Must be complete, e.g. b'command\r\n'
+        lines_expected: int
+            Number of interesting lines to be returned from the device. Any remaining output from the device will be
+            cleared. Note that having lines_expected larger than the actual number of reply lines for a given command
+            will not crash, but will take self.timeout seconds for each extra line requested.
+
+        Returns
+        -------
+        reply: list
+            list of lines retrieved from the device. Blank lines are possible
+
+        Notes
+        -----
+        serial.Serial.readlines method was not used because our device requires a wait until each line is read before
+        it writes the next line.
+        """
+        with self.lock:
+            self.com_port.reset_input_buffer()
+            self.com_port.write(command)
+            reply = [self.com_port.readline() for line in range(lines_expected)]
+            self.com_port.reset_input_buffer()
+        return reply
+
+    def GetStatus(self):
+        """
+        Initial properties. Must be called before polling starts.
+        """
+        raw_reply = self.query(b'S?\r\n', lines_expected=36)
+        reply = []
+        for line in raw_reply:
+            if line.startswith(b'\rl'):
+                reply.append(line)
+        for channel in range(self.n_chans):
+            retrm = reply[channel].replace(b'\x00', b'').replace(b'= ', b'=').replace(b'-', b'').strip()
+            s = re.compile(br'l(?P<channel>\d+) F=(?P<freq>\d+.\d+) P=(?P<power>\d+.\d+) (?P<onoff>\w+)')
+            vals = s.search(retrm)
+            self.freq[channel] = float(vals.group('freq'))
+            self.power[channel] = float(vals.group('power'))
+            self.channel_enabled[channel] = vals.group('onoff') == b'ON'
+
+    def Enable(self, channel):
+        if not self.is_on:
+            self.TurnOn()
+        # turn on the channel
+        self.query(b'L%dO1\r\n' % (channel + 1))
+        self.channel_enabled[channel] = True
+
+    def Disable(self, channel):
+        self.query(b'L%dO0\r\n' % (channel + 1))
+        self.channel_enabled[channel] = False
+
+    def SetPower(self, power, channel):
+        command = b'L%dD%2.2f' % (channel+1, power)
+
+        self.query(command + b'\r\n')
+        self.power[channel] = power
+
+    def GetPower(self, channel):
+        return self.power[channel]
+
+    def SetPowerAndEnable(self, power, channel):
+        command = b'L%dD%2.2f' % (channel+1, power)
+        if power > 0:
+            # make sure we're running
+            if not self.is_on:
+                self.TurnOn()
+            # enable the channel
+            command += b'O1'
+            self.channel_enabled[channel] = True
+
+        self.query(command + b'\r\n')
+        self.power[channel] = power
+
+    def SetFreq(self, freq, channel):
+        self.query(b'L%dF%3.2f\r\n' % (channel + 1, freq))
+        self.freq[channel] = freq
+
+    def GetFreq(self, channel):
+        return self.freq[channel]
+
+    def Close(self):
+        logger.debug('Shutting down %s' % self.name)
+        # shut down active channels
+        for channel in range(self.n_chans):
+            if self.channel_enabled[channel]:
+                try:
+                    self.Disable(channel)
+                except:
+                    pass
+
+        # close serial port
+        self.is_on = False
+        try:
+            self.com_port.close()
+        except Exception as e:
+            logger.error(str(e))

PYME/Acquire/Hardware/ARCoptix/lcdriver.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+"""
+Controls for the ARCoptix liquid crystal driver.
+
+Requirements: 
+    - Download and install the LC driver from http://www.arcoptix.com/pdf/LC_Driver_1_2.zip.
+      This should install to C:\Program Files\ARCoptix\ARCoptix LC Driver 1.2
+    - pip install pythonnet msl-loadlib
+
+This uses inter-process communication to access a 32-bit .NET DLL from 64-bit python.
+Pre-flight to create the 32-bit server:
+    - Create a 32-bit conda environment
+        - set CONDA_FORCE_32BIT=1
+        - conda create -n py37_32 python=3.7.9  # change this to the python used in your pyme install
+        - set CONDA_FORCE_32BIT=1
+        - activate py37_32
+        - pip install msl-loadlib pyinstaller comtypes pythonnet numpy  # make sure the versions match the versions in your 64-bit environment
+                                                                        # numpy is optional, but if you don't use it make sure you cast everything
+                                                                        # to float before passing to the server
+    - python
+        - from msl.loadlib import freeze_server32
+        - freeze_server32.main()
+        ... PyInstaller logging messages ...
+        Server saved to: ...
+    - Copy the generated server32-windows.exe file to 
+      miniconda3\envs\<64-bit pyme environment>\lib\site-packages\msl\loadlib
+    - Copy C:\Program Files\ARCoptix\ARCoptix LC Driver 1.2\CyUSB.dll to
+      miniconda3\envs\<pyme environment>\lib\site-packages\msl\loadlib.
+      NOTE: We shouldn't need to do this, but setting os.environ['PATH'] doesn't
+      update the path for server32-windows.exe. Ideally we'd find a way to do this
+      and add C:\Program Files\ARCoptix\ARCoptix LC Driver 1.2 to server32-windows.exe's
+      path.
+    - set CONDA_FORCE_32BIT=
+    - activate <pyme environment>
+
+Created on Fri January 08 2021
+
+@author: zacsimile
+"""
+
+import os
+import platform
+from msl.loadlib import Client64
+
+sys = platform.system()
+if sys != 'Windows':
+    raise Exception("Operating system is not supported.")
+
+class LCDriver(Client64):
+    def __init__(self):
+        """
+        Communicates with 32-bit LCDriver.dll library via lcserver32.py.
+        """
+        Client64.__init__(self, module32='lcserver32', 
+                            append_sys_path=os.path.dirname(__file__))
+    
+    def get_class_names(self):
+        """ Returns the class names in the library. """
+        return self.request32('get_class_names')
+
+    def get_number_of_devices_connected(self):
+        """
+        Returns the number of LCDrivers connected to the computer. device_number
+        in other functions is in the range 0 to (number of LCDrivers - 1).
+
+        Returns
+        -------
+        int
+            the number of LC drivers connected to the computer
+        """
+        return self.request32('get_number_of_devices_connected')
+
+    def get_serial_number(self, device_number=0):
+        """
+        Gets the serial number of the active device.
+
+        Parameters
+        ----------
+        device_number : int 
+            Index of the LCDriver
+
+        Returns
+        -------
+        string
+            Serial number of LCDriver
+        """
+        return self.request32('get_serial_number', device_number)
+
+    def get_max_voltage(self):
+        """
+        Gets the maximal possible output value for the LC driver.
+
+        Returns
+        -------
+        float
+            Max voltage
+        """
+        return self.request32('get_max_voltage')
+
+    def set_dac_voltage(self, V, ch_number, device_number=0):
+        """
+        Sets the output voltage in volts.
+
+        Parameters
+        ----------
+        V : float
+            output voltage
+        ch_number : int
+            channel number 0,1,2,3 or 4
+        device_number : int
+            Index of the LCDriver
+
+        Returns
+        -------
+        bool
+            True if command is sent successfully
+        """
+        return self.request32('set_dac_voltage', float(V), int(ch_number), int(device_number))
+
+    def set_triggers(self, out0external, out1external, out2external, out3external, 
+                        device_number=0):
+        """
+        Set the external trigger active for the outputs and for the device number device_number. 
+
+        Only possible to use if the trigger option is available on your LCDDriver!
+
+        Parameters
+        ----------
+        out0external : bool
+            channel 0 external trigger
+        out1external : bool
+            channel 1 external trigger
+        out2external : bool
+            channel 2 external trigger
+        out3external : bool
+            channel 3 external trigger
+
+        Returns
+        -------
+        bool
+            True if command is sent successfully
+        """
+        return self.request32('set_triggers', 
+                                out0external,
+                                out1external, 
+                                out2external, 
+                                out3external, 
+                                device_number)

PYME/Acquire/Hardware/ARCoptix/lcserver32.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+
+# Server class for LC Driver
+
+from msl.loadlib import Server32
+import clr  # need this to import types from system
+from System import Double, Byte, Boolean
+
+class LCServer(Server32):
+    def __init__(self, host, port, quiet, **kwargs):
+        """
+        A wrapper around 32-bit LCDriver.dll library.
+
+        Parameters
+        ----------
+        host : str
+            The IP address of the server.
+        port : int
+            The port to open on the server.
+        quiet : bool
+            Whether to hide :data:`sys.stdout` messages from the server.
+        """
+        Server32.__init__(self, 'C:\Program Files\ARCoptix\ARCoptix LC Driver 1.2\LCDriver.dll',
+                            'net', host, port, quiet)
+        # Need True flag to always open as if we might connect multiple LC driver devices
+        self.lcdriver = self.lib.ARCoptix.LCdriver.LCdriver(True)
+
+    def get_class_names(self):
+        """ Returns the class names in the library. """
+        return ';'.join(str(name) for name in self.assembly.GetTypes()).split(';')
+
+    def get_number_of_devices_connected(self):
+        """
+        Returns the number of LCDrivers connected to the computer. device_number
+        in other functions is in the range 0 to (number of LCDrivers - 1).
+
+        Returns
+        -------
+        int
+            the number of LC drivers connected to the computer
+        """
+        return self.lcdriver.GetNumberOfDevicesConnected()
+
+    def get_serial_number(self, device_number=0):
+        """
+        Gets the serial number of the active device.
+
+        Parameters
+        ----------
+        device_number : int 
+            Index of the LCDriver
+
+        Returns
+        -------
+        string
+            Serial number of LCDriver
+        """
+        return self.lcdriver.GetSerialNumber(device_number)
+
+    def get_max_voltage(self):
+        """
+        Gets the maximal possible output value for the LC driver.
+
+        Returns
+        -------
+        float
+            Max voltage
+        """
+        return self.lcdriver.GetMaxVoltage()
+
+    def set_dac_voltage(self, V, ch_number, device_number=0):
+        """
+        Sets the output voltage in volts.
+
+        Parameters
+        ----------
+        V : float
+            output voltage
+        ch_number : int
+            channel number 0,1,2,3 or 4
+        device_number : int
+            Index of the LCDriver
+
+        Returns
+        -------
+        bool
+            True if command is sent successfully
+        """
+        max_volts = self.get_max_voltage()
+        if V > max_volts:
+            V = max_volts
+        elif V < 0.0:
+            V = 0.0
+        return self.lcdriver.SetDACVoltage(Double(V), Byte(ch_number), device_number)
+
+    def set_triggers(self, out0external, out1external, out2external, out3external, 
+                        device_number=0):
+        """
+        Set the external trigger active for the outputs and for the device number device_number. 
+
+        Only possible to use if the trigger option is available on your LCDDriver!
+
+        Parameters
+        ----------
+        out0external : bool
+            channel 0 external trigger
+        out1external : bool
+            channel 1 external trigger
+        out2external : bool
+            channel 2 external trigger
+        out3external : bool
+            channel 3 external trigger
+
+        Returns
+        -------
+        bool
+            True if command is sent successfully
+        """
+        return self.lcdriver.SetTriggers(Boolean(out0external), 
+                                         Boolean(out1external), 
+                                         Boolean(out2external),
+                                         Boolean(out3external), 
+                                         device_number)