cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/filterwheel/eksma/testpythonfw.py

@@ -1,215 +0,0 @@
-from ctypes import *
-import time
-import os
-import sys
-import platform
-import tempfile
-import re
-
-if sys.version_info >= (3,0):
-    import urllib.parse
-
-# Dependences
-
-# For correct usage of the library libximc,
-# you need to add the file pyximc.py wrapper with the structures of the library to python path.
-cur_dir = os.path.abspath(os.path.dirname(__file__)) # Specifies the current directory.
-ximc_dir = os.path.join(cur_dir, "..", "..", "ximc") # Formation of the directory name with all dependencies. The dependencies for the examples are located in the ximc directory.
-ximc_package_dir = os.path.join(ximc_dir, "crossplatform", "wrappers", "python") # Formation of the directory name with python dependencies.
-sys.path.append(ximc_package_dir)  # add pyximc.py wrapper to python path
-
-# Depending on your version of Windows, add the path to the required DLLs to the environment variable
-# bindy.dll
-# libximc.dll
-# xiwrapper.dll
-try:
-    from egse.lib.ximc.pyximc import *
-except ImportError as err:
-    print ("Can't import pyximc module. The most probable reason is that you changed the relative location of the testpython.py and pyximc.py files. See developers' documentation for details.")
-    exit()
-except OSError as err:
-    print(err)
-    print ("Can't load libximc library. Please add all shared libraries to the appropriate places. It is decribed in detail in developers' documentation. On Linux make sure you installed libximc-dev package.\nmake sure that the architecture of the system and the interpreter is the same")
-    exit()
-
-def test_info(lib, device_id):
-    print("\nGet device info")
-    x_device_information = device_information_t()
-    result = lib.get_device_information(device_id, byref(x_device_information))
-    print("Result: " + repr(result))
-    if result == Result.Ok:
-        print("Device information:")
-        print(" Manufacturer: " +
-                repr(string_at(x_device_information.Manufacturer).decode()))
-        print(" ManufacturerId: " +
-                repr(string_at(x_device_information.ManufacturerId).decode()))
-        print(" ProductDescription: " +
-                repr(string_at(x_device_information.ProductDescription).decode()))
-        print(" Major: " + repr(x_device_information.Major))
-        print(" Minor: " + repr(x_device_information.Minor))
-        print(" Release: " + repr(x_device_information.Release))
-
-def test_status(lib, device_id):
-    print("\nGet status")
-    x_status = status_t()
-    result = lib.get_status(device_id, byref(x_status))
-    print("Result: " + repr(result))
-    if result == Result.Ok:
-        print("Status.Ipwr: " + repr(x_status.Ipwr))
-        print("Status.Upwr: " + repr(x_status.Upwr))
-        print("Status.Iusb: " + repr(x_status.Iusb))
-        print("Status.Flags: " + repr(hex(x_status.Flags)))
-
-def test_get_position(lib, device_id):
-    print("\nRead position")
-    x_pos = get_position_t()
-    result = lib.get_position(device_id, byref(x_pos))
-    print("Result: " + repr(result))
-    if result == Result.Ok:
-        print("Position: {0} steps, {1} microsteps".format(x_pos.Position, x_pos.uPosition))
-    return x_pos.Position, x_pos.uPosition
-
-def test_left(lib, device_id):
-    print("\nMoving left")
-    result = lib.command_left(device_id)
-    print("Result: " + repr(result))
-
-def test_move(lib, device_id, distance, udistance):
-    print("\nGoing to {0} steps, {1} microsteps".format(distance, udistance))
-    result = lib.command_move(device_id, distance, udistance)
-    print("Result: " + repr(result))
-
-def test_wait_for_stop(lib, device_id, interval):
-    print("\nWaiting for stop")
-    result = lib.command_wait_for_stop(device_id, interval)
-    print("Result: " + repr(result))
-
-def test_serial(lib, device_id):
-    print("\nReading serial")
-    x_serial = c_uint()
-    result = lib.get_serial_number(device_id, byref(x_serial))
-    if result == Result.Ok:
-        print("Serial: " + repr(x_serial.value))
-
-def test_get_speed(lib, device_id)        :
-    print("\nGet speed")
-    # Create move settings structure
-    mvst = move_settings_t()
-    # Get current move settings from controller
-    result = lib.get_move_settings(device_id, byref(mvst))
-    # Print command return status. It will be 0 if all is OK
-    print("Read command result: " + repr(result))
-
-    return mvst.Speed
-
-def test_set_speed(lib, device_id, speed):
-    print("\nSet speed")
-    # Create move settings structure
-    mvst = move_settings_t()
-    # Get current move settings from controller
-    result = lib.get_move_settings(device_id, byref(mvst))
-    # Print command return status. It will be 0 if all is OK
-    print("Read command result: " + repr(result))
-    print("The speed was equal to {0}. We will change it to {1}".format(mvst.Speed, speed))
-    # Change current speed
-    mvst.Speed = int(speed)
-    # Write new move settings to controller
-    result = lib.set_move_settings(device_id, byref(mvst))
-    # Print command return status. It will be 0 if all is OK
-    print("Write command result: " + repr(result))
-
-
-def test_set_microstep_mode_256(lib, device_id):
-    print("\nSet microstep mode to 256")
-    # Create engine settings structure
-    eng = engine_settings_t()
-    # Get current engine settings from controller
-    result = lib.get_engine_settings(device_id, byref(eng))
-    # Print command return status. It will be 0 if all is OK
-    print("Read command result: " + repr(result))
-    # Change MicrostepMode parameter to MICROSTEP_MODE_FRAC_256
-    # (use MICROSTEP_MODE_FRAC_128, MICROSTEP_MODE_FRAC_64 ... for other microstep modes)
-    eng.MicrostepMode = MicrostepMode.MICROSTEP_MODE_FRAC_256
-    # Write new engine settings to controller
-    result = lib.set_engine_settings(device_id, byref(eng))
-    # Print command return status. It will be 0 if all is OK
-    print("Write command result: " + repr(result))
-
-
-if __name__ == "__main__":
-    # variable 'lib' points to a loaded library
-    # note that ximc uses stdcall on win
-    print("Library loaded")
-
-    sbuf = create_string_buffer(64)
-    lib.ximc_version(sbuf)
-    print("Library version: " + sbuf.raw.decode().rstrip("\0"))
-
-    # Set bindy (network) keyfile. Must be called before any call to "enumerate_devices" or "open_device" if you
-    # wish to use network-attached controllers. Accepts both absolute and relative paths, relative paths are resolved
-    # relative to the process working directory. If you do not need network devices then "set_bindy_key" is optional.
-    # In Python make sure to pass byte-array object to this function (b"string literal").
-    lib.set_bindy_key(os.path.join(ximc_dir, "win32", "keyfile.sqlite").encode("utf-8"))
-
-    # This is device search and enumeration with probing. It gives more information about devices.
-    probe_flags = EnumerateFlags.ENUMERATE_PROBE + EnumerateFlags.ENUMERATE_NETWORK
-    enum_hints = b"addr=192.168.0.1,172.16.2.3"
-    # enum_hints = b"addr=" # Use this hint string for broadcast enumerate
-    devenum = lib.enumerate_devices(probe_flags, enum_hints)
-    print("Device enum handle: " + repr(devenum))
-    print("Device enum handle type: " + repr(type(devenum)))
-
-    dev_count = lib.get_device_count(devenum)
-    print("Device count: " + repr(dev_count))
-
-    controller_name = controller_name_t()
-    for dev_ind in range(0, dev_count):
-        enum_name = lib.get_device_name(devenum, dev_ind)
-        result = lib.get_enumerate_device_controller_name(devenum, dev_ind, byref(controller_name))
-        if result == Result.Ok:
-            print("Enumerated device #{} name (port name): ".format(dev_ind) + repr(enum_name) + ". Friendly name: " + repr(controller_name.ControllerName) + ".")
-
-    open_name = None
-    if len(sys.argv) > 1:
-        open_name = sys.argv[1]
-    elif dev_count > 0:
-        open_name = lib.get_device_name(devenum, 0)
-    elif sys.version_info >= (3,0):
-        # use URI for virtual device when there is new urllib python3 API
-        tempdir = tempfile.gettempdir() + "/testdevice.bin"
-        if os.altsep:
-            tempdir = tempdir.replace(os.sep, os.altsep)
-        # urlparse build wrong path if scheme is not file
-        uri = urllib.parse.urlunparse(urllib.parse.ParseResult(scheme="file", \
-                netloc=None, path=tempdir, params=None, query=None, fragment=None))
-        open_name = re.sub(r'^file', 'xi-emu', uri).encode()
-
-    if not open_name:
-        exit(1)
-
-    if type(open_name) is str:
-        open_name = open_name.encode()
-
-    print("\nOpen device " + repr(open_name))
-    device_id = lib.open_device(open_name)
-    print("Device id: " + repr(device_id))
-
-    test_info(lib, device_id)
-    test_status(lib, device_id)
-    test_set_microstep_mode_256(lib, device_id)
-    startpos, ustartpos = test_get_position(lib, device_id)
-    # first move
-    test_left(lib, device_id)
-    time.sleep(3)
-    test_get_position(lib, device_id)
-    # second move
-    current_speed = test_get_speed(lib, device_id)
-    test_set_speed(lib, device_id, current_speed / 2)
-    test_move(lib, device_id, startpos, ustartpos)
-    test_wait_for_stop(lib, device_id, 100)
-    test_status(lib, device_id)
-    test_serial(lib, device_id)
-
-    print("\nClosing")
-    lib.close_device(byref(cast(device_id, POINTER(c_int))))
-    print("Done")

egse/fov/__init__.py

@@ -1,65 +0,0 @@
-import logging
-
-from egse.control import Failure
-from egse.storage import StorageProxy
-from egse.synoptics import SynopticsManagerProxy
-from egse.system import format_datetime
-
-LOGGER = logging.getLogger(__name__)
-ORIGIN = "FOV"
-
-
-def store_actual_fov_position(theta: float, phi: float):
-    """ Store the given actual FOV position in the FOV position HK file.
-
-    Args:
-        - theta: Actual gnomonic distance to the optical axis [degrees].
-        - phi: Actual in-field angle [degrees].
-    """
-
-    try:
-
-        with StorageProxy() as storage:
-
-            data = {"timestamp": format_datetime(), "FOV_ACT_THETA": theta, "FOV_ACT_PHI": phi}
-            response = storage.save({"origin": ORIGIN, "data": data})
-
-            # Store the actual FOV positions as synoptics
-
-            with SynopticsManagerProxy() as synoptics:
-                synoptics.store_common_synoptics(data)
-
-            if isinstance(response, Failure):
-                LOGGER.warning("Failed to store the actual FOV position.  Check the status of fov_hk.")
-
-    except ConnectionError as exc:
-        LOGGER.warning(f"Couldn't connect to the Storage Manager to store the actual FOV position: {exc}")
-
-
-def store_commanded_fov_position(theta: float, phi: float):
-    """ Store the given commanded FOV position in the FOV position HK file.
-
-    This method will be called from the MGSE commanding in plato-test-scripts.
-
-    Args:
-        - theta: Commanded gnomonic distance to the optical axis [degrees].
-        - phi: Commanded in-field angle [degrees].
-    """
-
-    try:
-
-        with StorageProxy() as storage:
-
-            data = {"timestamp": format_datetime(), "FOV_CMD_THETA": theta, "FOV_CMD_PHI": phi}
-            response = storage.save({"origin": ORIGIN, "data": data})
-
-            # Store the commanded FOV positions as synoptics
-
-            with SynopticsManagerProxy() as synoptics:
-                synoptics.store_common_synoptics(data)
-
-            if isinstance(response, Failure):
-                LOGGER.info("fov_hk is not running: the commanded position cannot be stored")
-
-    except ConnectionError as exc:
-        LOGGER.warning(f"Couldn't connect to the Storage Manager to store the actual FOV position: {exc}")