feather-xrol 0.1.0__tar.gz

feather_xrol-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Dream Beam
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

feather_xrol-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: feather-xrol
+Version: 0.1.0
+Summary: Bluesky and Ophyd integration for Attocube interferometer and Hexapod
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bluesky
+Requires-Dist: ophyd
+Requires-Dist: pyepics
+Requires-Dist: tiled
+Requires-Dist: python-dotenv
+Dynamic: license-file
+
+# Project Feather 
+contact: awojdyla@lbl.gov
+![Starlings in flight](/assets/starlings_flach.jpg)
+
+Project Feather aims at expending the use of [bluesky data collection framework](https://blueskyproject.io/bluesky/main/index.html) beyond synchrotron beamlines
+
+We want to use Tiled to collect data from optical experiments, or to store metrology data so that it can easily be accessed.
+
+Eventually, you might even be able to start a container that has everything you need.
+
+## feather-xrol Package
+
+Integration for Attocube interferometer and Hexapod.
+
+### Installation
+
+#### From Source (Development)
+To install the package locally in editable mode for development:
+```bash
+pip install -e .
+```
+
+### Usage
+
+The package provides Ophyd device definitions for the ALSHexapod and Attocube interferometer.
+
+#### Hexapod Example
+See `examples/hexapod_scan.py` for a complete example of running a scan.
+```python
+from feather_xrol.hexapod import ALSHexapod
+from bluesky import RunEngine
+from bluesky.plans import scan
+
+hexapod = ALSHexapod('ALS:XROL-HEX0', name='hexapod')
+RE = RunEngine({})
+RE(scan([hexapod.x], hexapod.x, 0.0, 5.0, 10))
+```
+
+#### Attocube Example
+See `examples/test_attocube.py` for Attocube axis integration.
+```python
+from feather_xrol.attocube import AttocubeAxis
+from feather_xrol.ids_api.SEN import Device as AttocubeIDS3010
+
+ids3010 = AttocubeIDS3010("192.168.10.81")
+ids3010.connect()
+atto = AttocubeAxis("atto_3", hardware_interface=ids3010, axis=2)
+atto.trigger()
+print(atto.read())
+ids3010.close()
+```

feather_xrol-0.1.0/README.md

@@ -0,0 +1,51 @@
+# Project Feather 
+contact: awojdyla@lbl.gov
+![Starlings in flight](/assets/starlings_flach.jpg)
+
+Project Feather aims at expending the use of [bluesky data collection framework](https://blueskyproject.io/bluesky/main/index.html) beyond synchrotron beamlines
+
+We want to use Tiled to collect data from optical experiments, or to store metrology data so that it can easily be accessed.
+
+Eventually, you might even be able to start a container that has everything you need.
+
+## feather-xrol Package
+
+Integration for Attocube interferometer and Hexapod.
+
+### Installation
+
+#### From Source (Development)
+To install the package locally in editable mode for development:
+```bash
+pip install -e .
+```
+
+### Usage
+
+The package provides Ophyd device definitions for the ALSHexapod and Attocube interferometer.
+
+#### Hexapod Example
+See `examples/hexapod_scan.py` for a complete example of running a scan.
+```python
+from feather_xrol.hexapod import ALSHexapod
+from bluesky import RunEngine
+from bluesky.plans import scan
+
+hexapod = ALSHexapod('ALS:XROL-HEX0', name='hexapod')
+RE = RunEngine({})
+RE(scan([hexapod.x], hexapod.x, 0.0, 5.0, 10))
+```
+
+#### Attocube Example
+See `examples/test_attocube.py` for Attocube axis integration.
+```python
+from feather_xrol.attocube import AttocubeAxis
+from feather_xrol.ids_api.SEN import Device as AttocubeIDS3010
+
+ids3010 = AttocubeIDS3010("192.168.10.81")
+ids3010.connect()
+atto = AttocubeAxis("atto_3", hardware_interface=ids3010, axis=2)
+atto.trigger()
+print(atto.read())
+ids3010.close()
+```

feather_xrol-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "feather-xrol"
+version = "0.1.0"
+description = "Bluesky and Ophyd integration for Attocube interferometer and Hexapod"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "bluesky",
+    "ophyd",
+    "pyepics",
+    "tiled",
+    "python-dotenv"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

feather_xrol-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

feather_xrol-0.1.0/src/feather_xrol/__init__.py

@@ -0,0 +1,2 @@
+from .hexapod import ALSHexapod
+from .attocube import AttocubeAxis

feather_xrol-0.1.0/src/feather_xrol/attocube.py

@@ -0,0 +1,50 @@
+import time
+from ophyd import Device
+from ophyd.status import DeviceStatus
+
+PM_TO_MM = 1e-9
+
+class AttocubeAxis(Device):
+
+    def __init__(self, *args, hardware_interface, axis: int, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._hw = hardware_interface
+        self._axis = axis
+        self._position_mm = None
+        self._timestamp = None
+        
+    def trigger(self):
+        status = DeviceStatus(self)
+        try:
+            error, value = self._hw.displacement.getAbsolutePosition(self._axis)
+            if not error:
+                self._position_mm = value * PM_TO_MM
+                self._timestamp = time.time()
+                status.set_finished()
+            else:
+                status.set_exception(Exception(f"Attocube error code: {error}"))
+        except Exception as exc:
+            status.set_exception(exc)
+        return status
+
+    def read(self):
+        return {
+            self.name: {
+                "value": self._position_mm,
+                "timestamp": self._timestamp,
+            }
+        }
+
+    def describe(self):
+        return {
+            self.name: {
+                "source": f"AttocubeIDS3010:axis{self._axis}",
+                "dtype": "number",
+                "shape": [],
+                "units": "mm",
+            }
+        }
+
+    @property
+    def hints(self):
+        return {"fields": [self.name]}

feather_xrol-0.1.0/src/feather_xrol/hexapod.py

@@ -0,0 +1,27 @@
+from ophyd import Device, PVPositioner, EpicsSignal, EpicsSignalRO
+from ophyd import Component as Cpt, FormattedComponent as FCpt
+
+class HexapodAxis(PVPositioner):
+    setpoint   = Cpt(EpicsSignal,   ':TARGET')
+    readback   = Cpt(EpicsSignalRO, ':POSITION')
+    done       = FCpt(EpicsSignalRO, '{self.parent.prefix}-alldone')
+    done_value = 'done'
+    high_limit = Cpt(EpicsSignalRO, ':HLM')
+    low_limit  = Cpt(EpicsSignalRO, ':LLM')
+    servo      = Cpt(EpicsSignal,   ':SERVO')
+    rb_servo   = Cpt(EpicsSignalRO, ':RBSERVO')
+
+class ALSHexapod(Device):
+    """ALS XROL Hexapod — 6DOF (X, Y, Z, U, V, W)"""
+    x = Cpt(HexapodAxis, '-X')
+    y = Cpt(HexapodAxis, '-Y')
+    z = Cpt(HexapodAxis, '-Z')
+    u = Cpt(HexapodAxis, '-U')
+    v = Cpt(HexapodAxis, '-V')
+    w = Cpt(HexapodAxis, '-W')
+    # Shared status / control
+    alldone   = Cpt(EpicsSignalRO, '-alldone')
+    allstop   = Cpt(EpicsSignal,   '-allstop')
+    moving    = Cpt(EpicsSignalRO, '-moving')
+    clear_err = Cpt(EpicsSignal,   '-CLEAR_ERR')
+    last_err  = Cpt(EpicsSignalRO, '-LAST_ERR')

feather_xrol-0.1.0/src/feather_xrol/ids_api/ACS.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import socket
+import json
+
+from time import time, sleep
+
+from random import randint
+
+from threading import Thread, Lock
+try:
+    import netifaces
+except:
+    pass
+
+import urllib.request
+import xml.dom.minidom as minidom
+
+class AttoException(Exception):
+    def __init__(self, errorText = None, errorNumber = 0):
+        self.errorText = errorText
+        self.errorNumber = errorNumber
+
+class AttoResult():
+    def __init__(self, resultDict):
+        self.resultDict = resultDict
+
+    def __getitem__(self, index):
+        if "error" in self.resultDict:
+            raise AttoException("JSON error in %s" % self.resultDict['error'])
+
+        resultList = self.resultDict.get("result", [])
+        if len(resultList) <= index:
+            raise AttoException(errorText="Unknown error occured", errorNumber=-1)
+        return resultList[index]
+
+    def __repr__(self):
+        return json.dumps(self.resultDict)
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class Device(object):
+    TCP_PORT        = 9090
+    is_open         = False
+    request_id      = randint(0, 1000000)
+    request_id_lock = Lock()
+    response_buffer = {}
+
+    def __init__(self, address):
+        self.address        = address
+        self.language       = 0
+        self.apiversion     = 2
+        self.response_lock  = Lock()
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def connect(self):
+        """
+            Initializes and connects the selected AMC device.
+        """
+        if not self.is_open:
+            tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            tcp.settimeout(10)
+            tcp.connect((self.address, self.TCP_PORT))
+            self.tcp = tcp
+            if sys.version_info[0] > 2:
+                self.bufferedSocket = tcp.makefile("rw", newline='\r\n')
+            else:
+                self.bufferedSocket = tcp.makefile("rw")
+            self.is_open = True
+
+    def close(self):
+        """
+            Closes the connection to the device.
+        Returns
+        -------
+        """
+        if self.is_open:
+            self.bufferedSocket.close()
+            self.tcp.close()
+            self.is_open = False
+
+    def sendRequest(self, method, params=False):
+        req = {
+                "jsonrpc": "2.0",
+                "method": method,
+                "api": self.apiversion,
+                "pid": self.pid
+              }
+        if params:
+            req["params"] = params
+        with Device.request_id_lock:
+            req["id"] = Device.request_id
+            self.bufferedSocket.write(json.dumps(req))
+            self.bufferedSocket.flush()
+            Device.request_id = Device.request_id + 1
+            return req["id"]
+
+    def getResponse(self, request_id):
+        start_time = time()
+        while True:
+            if request_id in self.response_buffer:
+                response = self.response_buffer[request_id]
+                del self.response_buffer[request_id]
+                return response
+            if time() - start_time > 10:
+                raise TimeoutError("No result")
+
+            # Only one thread is allowed to read buffer
+            # Otherwise, deadlock is possible
+            if self.response_lock.acquire(blocking=False):
+                try:
+                    response = self.bufferedSocket.readline()
+                    parsed = json.loads(response)
+                    if parsed["id"] == request_id:
+                        return AttoResult(parsed)
+                    else:
+                        self.response_buffer[parsed["id"]] = AttoResult(parsed)
+                finally:
+                    self.response_lock.release()
+            else:
+                # Sleep to unblock scheduler
+                sleep(0.01)
+
+
+    def request(self,method,params=False):
+        """ Synchronous request.
+        """
+        if not self.is_open:
+            raise AttoException("not connected, use connect()");
+        request_id = self.sendRequest(method, params)
+        return self.getResponse(request_id)
+
+    def printError(self, errorNumber):
+        """ Converts the errorNumber into an error string an prints it to the
+        console.
+        Parameters
+        ----------
+        errorNumber : int
+        """
+        print("Error! " + str(self.system_service.errorNumberToString(self.language, errorNumber)[1]))
+
+    def handleError(self, response, ignoreFunctionError=False):
+        errNo = response[0]
+        if (errNo != 0 and errNo != 'null' and not ignoreFunctionError):
+            raise AttoException(("Error! " + str(self.system_service.errorNumberToString(self.language ,errNo))), errNo)
+        return errNo
+
+    @staticmethod
+    def discover(cls):
+        try:
+            network_ifaces = netifaces.interfaces()
+        except NameError:
+            print("Install netifaces for discovery")
+            print("Python:")
+            print("pip install netifaces")
+            print("\nPython3:")
+            print("pip3 install netifaces")
+            return {}
+
+        msg = \
+           'M-SEARCH * HTTP/1.1\r\n' \
+           'HOST:239.255.255.250:1900\r\n' \
+           'ST:urn:schemas-attocube-com:device:' + str(cls) + ':1\r\n' \
+           'MX:2\r\n' \
+           'MAN:"ssdp:discover"\r\n' \
+           '\r\n'
+
+        def send_and_recv(iface, devices, devices_lock):
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+            s.bind((iface, 0))
+            s.settimeout(2)
+            s.sendto(str.encode(msg), ('239.255.255.250', 1900))
+            try:
+                while True:
+                    _, addr = s.recvfrom(65507)
+                    with devices_lock:
+                        devices.append(addr[0])
+            except socket.timeout:
+                pass
+
+        thread_pool = []
+        devices = []
+        devices_lock = Lock()
+
+        for iface in network_ifaces:
+            addr = netifaces.ifaddresses(iface)
+            if netifaces.AF_INET not in addr:
+                continue
+            for ip in addr[netifaces.AF_INET]:
+                if "addr" not in ip:
+                    continue
+                thread_pool.append(Thread(target=send_and_recv, args=(ip["addr"], devices, devices_lock)))
+                thread_pool[-1].start()
+
+        for thread in thread_pool:
+            thread.join()
+
+        def getElementData(xmlNode, tag):
+            tagNodes = xmlNode.getElementsByTagName(tag)
+            if len(tagNodes) == 0:
+                return None
+            childNodes = tagNodes[0].childNodes
+            if len(childNodes) == 0:
+                return None
+            return childNodes[0].data
+
+        deviceInfos = {}
+        for ip in devices:
+            try:
+                location = "http://" + ip + ":49000/upnp.xml"
+                response = urllib.request.urlopen(location)
+                response = response.read()
+                xmlNode = minidom.parseString(response)
+
+                serialNumber = getElementData(xmlNode, 'serialNumber')
+                ipAddress = getElementData(xmlNode, 'ipAddress')
+                macAddress = getElementData(xmlNode, 'macAddress')
+                friendlyName = getElementData(xmlNode, 'friendlyName')
+                modelName = getElementData(xmlNode, 'modelName')
+                lockedStatus = getElementData(xmlNode, 'lockedStatus')
+
+                deviceInfos[ip] = (
+                    serialNumber,
+                    ipAddress,
+                    macAddress,
+                    friendlyName,
+                    modelName,
+                    lockedStatus
+                )
+            except:
+                pass
+
+        return deviceInfos

feather_xrol-0.1.0/src/feather_xrol/ids_api/Examples/IDS_Example.py

@@ -0,0 +1,57 @@
+from ids_api import SEN # IDS API is the folder, in which the API is located.
+
+import time
+
+IP = "192.168.1.1" # IP of the IDS device
+checkAlignment = True
+data_samples = 10
+
+# Setup connection to IDS
+ids = SEN.Device(IP)
+ids.connect()
+   
+axis = 0 # Internally, axes are numbered 0 to 2
+
+ids.displacement.setAverageN(14) # this is important: it sets the average of the IDS displacement 
+
+# check alignment
+if checkAlignment:
+    if ids.system.getCurrentMode() == 'measurement running':
+        ids.system.stopMeasurement()
+        time.sleep(3)
+        
+    if ids.system.getCurrentMode() == "system idle":
+        ids.system.startOpticsAlignment()
+        while ids.system.getCurrentMode() == 'optics alignment starting':
+            time.sleep(1)
+    for i in range(5):
+        print("Alignment: ", ids.adjustment.getContrastInPermille(axis))
+    ids.system.stopOpticsAlignment()
+    time.sleep(5)
+    
+
+# check if the IDS measurement is running and start the measurement: 
+if ids.system.getCurrentMode() != 'measurement running':
+    if ids.system.getCurrentMode() == "optics alignment running":
+        ids.system.stopOpticsAlignment()
+        time.sleep(3)
+    if ids.system.getCurrentMode() == "system idle":
+        ids.system.startMeasurement()
+        time.sleep(1)
+        print('measurement will be started')
+        while ids.system.getCurrentMode() == "measurement starting":
+            time.sleep(2)
+
+if ids.system.getCurrentMode() != 'measurement running':
+    raise Exception("IDS not in measurement mode. Please check mode!")
+
+# readout data
+for i in range(data_samples):
+    error, value = ids.displacement.getAxisDisplacement(axis)
+    print("Displacement: ", value)
+    time.sleep(0.5)    
+    
+# turn off measurement mode
+ids.system.stopMeasurement()
+
+ids.close()

feather_xrol-0.1.0/src/feather_xrol/ids_api/SEN.py

@@ -0,0 +1,51 @@
+from . import ACS
+from .pilotlaser import Pilotlaser
+from .update import Update
+from .system import System
+from .nlc import Nlc
+from .realtime import Realtime
+from .access import Access
+from .adjustment import Adjustment
+from .ecu import Ecu
+from .manual import Manual
+from .system_service import System_service
+from .about import About
+from .axis import Axis
+from .network import Network
+from .displacement import Displacement
+try:
+    from .streaming.streaming import Streaming
+except:
+    pass
+
+
+class Device(ACS.Device):
+    def __init__(self, address):
+        super().__init__(address)
+        self.pid = "sen"
+        self.pilotlaser = Pilotlaser(self)
+        self.update = Update(self)
+        self.system = System(self)
+        self.nlc = Nlc(self)
+        self.realtime = Realtime(self)
+        self.access = Access(self)
+        self.adjustment = Adjustment(self)
+        self.ecu = Ecu(self)
+        self.manual = Manual(self)
+        self.system_service = System_service(self)
+        self.about = About(self)
+        self.axis = Axis(self)
+        self.network = Network(self)
+        self.displacement = Displacement(self)
+        
+        try:
+            self.streaming = Streaming(self)
+        except NameError as e:
+            if "Streaming" in str(e):
+                print("Warning: Streaming is not supported on your platform")
+            else:
+                raise e
+        
+
+def discover():
+    return Device.discover("sen")

feather_xrol-0.1.0/src/feather_xrol/ids_api/__init__.py

@@ -0,0 +1 @@
+# This marks the directory as a Python package

feather_xrol-0.1.0/src/feather_xrol/ids_api/about.py

@@ -0,0 +1,37 @@
+class About:
+    def __init__(self, device):
+        self.device = device
+        self.interface_name = "com.attocube.system.about"
+
+    def getInstalledPackages(self):
+        # type: () -> (str)
+        """
+        Gets list of packages installed on the device.
+        Returns:
+            value_errNo: errNo error code, if there was an error, otherwise 0 for ok
+            value_string: string comma separated list of packages
+                    
+        """
+        
+        response = self.device.request(self.interface_name + ".getInstalledPackages")
+        self.device.handleError(response)
+        return response[1]                
+
+    def getPackageLicense(self, pckg):
+        # type: (str) -> (str)
+        """
+        Gets the license for a specific package.
+
+        Parameters:
+            pckg: package name string
+                    
+        Returns:
+            value_errNo: errNo error code, if there was an error, otherwise 0 for ok
+            value_string: string license for this package
+                    
+        """
+        
+        response = self.device.request(self.interface_name + ".getPackageLicense", [pckg, ])
+        self.device.handleError(response)
+        return response[1]                
+