diff --git a/.idea/lasercontrol.iml b/.idea/lasercontrol.iml index d1e11dbb8e60eed370550e11314440df6000500d..cfb4a7c9199927c8a6dee0dc42fe9ee02f1e49d9 100644 --- a/.idea/lasercontrol.iml +++ b/.idea/lasercontrol.iml @@ -7,7 +7,7 @@ <excludeFolder url="file://$MODULE_DIR$/.venv310" /> <excludeFolder url="file://$MODULE_DIR$/.venv37" /> </content> - <orderEntry type="jdk" jdkName="Python 3.7 (lasercontrol)" jdkType="Python SDK" /> + <orderEntry type="jdk" jdkName="Python 3.10 (lasercontrol) (3)" jdkType="Python SDK" /> <orderEntry type="sourceFolder" forTests="false" /> </component> <component name="PyNamespacePackagesService"> diff --git a/.idea/misc.xml b/.idea/misc.xml index db7b81764f2cdf8ba5cf52429b150adc7a91c30d..9a4f28761322db8ad5200bfcdea47eb433ce1269 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -3,5 +3,5 @@ <component name="Black"> <option name="sdkName" value="Python 3.10 (lasercontrol) (2)" /> </component> - <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7 (lasercontrol)" project-jdk-type="Python SDK" /> + <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (lasercontrol) (3)" project-jdk-type="Python SDK" /> </project> \ No newline at end of file diff --git a/LaserConfig.yaml b/LaserConfig.yaml index 599299acbf296b495eb733895bb3a912c34ab792..b2330efcb37ccd74fcdfa90e6549cc124343035b 100644 --- a/LaserConfig.yaml +++ b/LaserConfig.yaml @@ -1,4 +1,4 @@ -# - Configuration file stored 2024-01-22 15:16:36.656752 - +# - Configuration file stored 2024-07-30 12:55:54.088188 - LaserConfig: #!!python/object:controller.LaserConfig wl_sweep_start: 857 # wl_sweep_start: None wl_sweep_stop: 870 # wl_sweep_stop: None diff --git a/examples/main.py b/examples/main.py index d717d10fb7814b84b4dcf4b9c2f7a8c97914d4ef..7f2faa2ea4330e7a1b47226a538a3cd42b7eac25 100644 --- a/examples/main.py +++ b/examples/main.py @@ -3,7 +3,7 @@ import sys from PySide6.QtWidgets import QApplication from rich.logging import RichHandler -sys.path.append('./src') +sys.path.append('../src') import LaserControl as Laser if __name__ == "__main__": @@ -33,10 +33,10 @@ if __name__ == "__main__": controller.internal_log_enabled = True window = Laser.View(model, controller) - controller.start_wavelength_sweep.emit( - model.sweep_start_wavelength, - model.sweep_stop_wavelength, - ) + #controller.start_wavelength_sweep.emit( + # model.sweep_start_wavelength, + # model.sweep_stop_wavelength, + #) window.show() diff --git a/examples/test_with_captdev.py b/examples/test_with_captdev.py index ce170bf1910927375902c41e07b9b6beaaa7c675..a30faeed6291dbefadadb17e5d84ca26ce6b0844 100644 --- a/examples/test_with_captdev.py +++ b/examples/test_with_captdev.py @@ -7,7 +7,7 @@ from PySide6.QtWidgets import QApplication import CaptDeviceControl as captdev -sys.path.append('./src') +sys.path.append('../src') import LaserControl as Laser if __name__ == "__main__": @@ -24,7 +24,7 @@ if __name__ == "__main__": app = QApplication.instance() conf_capt_dev = captdev.Config() - conf_capt_dev.load("CaptDeviceConfig.yaml") + #conf_capt_dev.load("CaptDeviceConfig.yaml") conf_capt_dev.autosave() start_capture_flag = Value('i', 0) diff --git a/src/LaserControl/controller/LaserCon.py b/src/LaserControl/controller/LaserCon.py index ba94d03023b111a7e1c86950d292149b0a1fa255..58bc72dddf7d2686601bb51d5e21806cc099b1de 100644 --- a/src/LaserControl/controller/LaserCon.py +++ b/src/LaserControl/controller/LaserCon.py @@ -19,10 +19,12 @@ else: dir = str(dir.resolve()) with os.add_dll_directory(dir): os.environ['PATH'] = dir + os.pathsep + os.environ['PATH'] - from LaserControl.libs.LaserLib import laserSacher as LaserLib + from LaserControl.libs import SacherMotorControl as LaserLib + except Exception as e: from LaserControl.libs.LaserLibSimulator import LaserLibSimulator as LaserLib - print(f"********** SIMUALTOR (Fallback) **********") + print(f"********** SIMUALTOR (Fallback) ********** {e}") + #exit() @contextmanager @@ -64,6 +66,8 @@ def stdout_redirector(stream): # os.dup2(saved_stdout_fd, sys.stdout.fileno()) # sys.stdout = original + + class LaserCon(object): def __init__(self, port, logger=None): @@ -98,9 +102,9 @@ class LaserCon(object): def _connect_to_laser(self, laser_conn, laser_port): self.logger.info(f"Connection to Laser on Port {laser_port}.") - f = io.StringIO() - # with stdout_redirector(f): - # laser_conn.connectMotor(f"{laser_port}") + + laser_conn.connect(f"{laser_port}") + self._connected = True return self._connected diff --git a/src/LaserControl/controller/LaserDeviceControl.py b/src/LaserControl/controller/LaserDeviceControl.py index 7150ac296cfa72b65606b1ad22bddd4cd2bc8ecd..bf7c46a27c479255eaef095e3d73d53031851f2e 100644 --- a/src/LaserControl/controller/LaserDeviceControl.py +++ b/src/LaserControl/controller/LaserDeviceControl.py @@ -12,10 +12,20 @@ from LaserControl.model.LaserControlModel import LaserControlModel class MPLaserDeviceControl(CProcessControl): connected_changed = Signal(bool, name='connected_changed') + + + # Properties current_wavelength_changed = Signal(float, name='current_wavelength_changed') + min_wavelength_changed = Signal(float, name='min_wavelength_changed') + max_wavelength_changed = Signal(float, name='max_wavelength_changed') + velocity_changed = Signal(float, name='velocity_changed') + acceleration_changed = Signal(float, name='acceleration_changed') + deceleration_changed = Signal(float, name='deceleration_changed') get_min_wavelength_finished = Signal(float, name='get_min_wavelength_finished') + + get_max_wavelength_finished = Signal(float, name='get_max_wavelength_finished') get_velocity_finished = Signal(float, name='get_velocity_finished') get_acceleration_finished = Signal(float, name='get_acceleration_finished') @@ -53,19 +63,19 @@ class MPLaserDeviceControl(CProcessControl): self.current_wavelength_changed.connect( lambda x: type(self.model).current_wavelength.fset(self.model, x)) - self.get_min_wavelength_finished.connect( + self.min_wavelength_changed.connect( lambda x: type(self.model).min_laser_wavelength.fset(self.model, x)) - self.get_max_wavelength_finished.connect( + self.max_wavelength_changed.connect( lambda x: type(self.model).max_laser_wavelength.fset(self.model, x)) - self.get_velocity_finished.connect( + self.velocity_changed.connect( lambda x: type(self.model).velocity.fset(self.model, x)) - self.get_acceleration_finished.connect( + self.acceleration_changed.connect( lambda x: type(self.model).acceleration.fset(self.model, x)) - self.get_deceleration_finished.connect( + self.deceleration_changed.connect( lambda x: type(self.model).deceleration.fset(self.model, x)) self.move_to_wavelength_finished.connect(self._move_to_wavelength_finished) @@ -77,6 +87,7 @@ class MPLaserDeviceControl(CProcessControl): self.start_wavelength_sweep.connect(self._start_wavelength_sweep) self.kill_thread = False + print("Inintializing MPLaserDeviceControl") def _on_connected_changed(self, connected: bool): if connected: @@ -117,6 +128,10 @@ class MPLaserDeviceControl(CProcessControl): def get_deceleration(self): self._module_logger.info("Reading deceleration from process.") + @cmp.CProcessControl.register_function() + def dev_connect(self, usb_port: str): + self._module_logger.info(f"RConnecting to process using {usb_port}") + @cmp.CProcessControl.register_function(mp_read_laser_settings_finished) def read_laser_settings(self, usb_port: str): self._module_logger.info(f"Reading laser settings from process using {usb_port}") diff --git a/src/LaserControl/controller/multiprocess/MPLaserDevice.py b/src/LaserControl/controller/multiprocess/MPLaserDevice.py index b8cd0ec67523585d419c735aa22328b353fe3aa8..86945225d4d354b316d776503b24fe2f79788f81 100644 --- a/src/LaserControl/controller/multiprocess/MPLaserDevice.py +++ b/src/LaserControl/controller/multiprocess/MPLaserDevice.py @@ -1,10 +1,20 @@ +import os +import pathlib import time from multiprocessing import Value import cmp from cmp.CProperty import CProperty -from LaserControl.controller.LaserCon import LaserCon +# from LaserControl.controller.LaserCon import LaserCon +dir = pathlib.Path(f"{os.path.dirname(os.path.realpath(__file__))}/../../libs") +dir = str(dir.resolve()) + +# Copy the dll to the startup directory + + + +from LaserControl.libs import SacherMotorControl as LaserLib class MPLaserDevice(cmp.CProcess): @@ -27,6 +37,15 @@ class MPLaserDevice(cmp.CProcess): self._connected = False self._current_wavelength = -1 + self._min_wavelength = 0 + self._max_wavelength = 0 + self._velocity = 0 + self._acceleration = 0 + self._deceleration = 0 + + + + self._laser_moving = False self.laser_moving_flag = laser_moving_flag @@ -35,22 +54,43 @@ class MPLaserDevice(cmp.CProcess): self._wavelength_sweep_running = False - def wrap_func(self, func, con: LaserCon = None, usb_port: str = None): - res = None - if usb_port is not None and con is None: - with LaserCon(usb_port) as con: - self.get_connected(con) - res = func(con) - self.get_connected(con) - elif usb_port is None and con is not None and isinstance(con, LaserCon): - res = func(con) - elif usb_port is None and con is None: - self.logger.error("USB Port or a connection object must be provided!") - raise ValueError("USB Port or a connection object must be provided!") - else: - self.logger.warning(f"Warning: {con}: LaserCon = None, {usb_port}: str = None") - self._module_logger.debug(f"Result of {func.__name__} is {res}") - return res + def postrun_init(self): + self.laser = LaserLib.Motor() + + @cmp.CProcess.register_signal() + def dev_connect(self, usb_port: str) -> bool: + """ + Connect to the laser on the specified USB port. + :param usb_port: USB port to connect to + :return: True if connected, False otherwise + """ + self.logger.info(f"Connecting to laser on port {usb_port}") + self.read_laser_settings() + try: + self.laser.connect(usb_port) + self.connected = True + except Exception as e: + self.logger.error(f"Error connecting to laser: {e}") + self.connected = False + + raise e + + + + return self._connected + + @CProperty + def min_wavelength(self): + return self._min_wavelength + + @CProperty + def max_wavelength(self): + return self._max_wavelength + + + + + @CProperty def wavelength_sweep_running(self): @@ -60,6 +100,17 @@ class MPLaserDevice(cmp.CProcess): def wavelength_sweep_running(self, value: bool): self._wavelength_sweep_running = value + + @CProperty + def connected(self): + return self._connected + + @connected.setter('connected_changed') + def connected(self, value: float): + self._connected = value + + # ================================================================================================================== + @CProperty def current_wavelength(self): return self._current_wavelength @@ -69,74 +120,118 @@ class MPLaserDevice(cmp.CProcess): self._current_wavelength = value @CProperty - def connected(self): - return self._connected + def min_wavelength(self): + return self._min_wavelength - @connected.setter('connected_changed') - def connected(self, value: float): - self._connected = value + @min_wavelength.setter('min_wavelength_changed') + def min_wavelength(self, value: float): + self._min_wavelength = value - @cmp.CProcess.register_signal() - def get_connected(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> bool: - def func(_con: LaserCon): - return _con.connected - self.connected = self.wrap_func(func, con, usb_port) - return self.connected + # ================================================================================================================== - @cmp.CProcess.register_signal() - def get_current_wavelength(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(_con: LaserCon): - return _con.current_wavelength + @CProperty + def max_wavelength(self): + return self._max_wavelength - self.current_wavelength = self.wrap_func(func, con, usb_port) - return self.current_wavelength + @max_wavelength.setter('max_wavelength_changed') + def max_wavelength(self, value: float): + self._max_wavelength = value - @cmp.CProcess.register_signal(postfix="_finished") - def get_min_wavelength(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(_con: LaserCon): - return _con.min_wavelength + # ================================================================================================================== - return self.wrap_func(func, con, usb_port) + @CProperty + def velocity(self): + return self._velocity - @cmp.CProcess.register_signal(postfix="_finished") - def get_max_wavelength(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(_con: LaserCon): - return _con.max_wavelength + @velocity.setter('velocity_changed') + def velocity(self, value: float): + self._velocity = value - return self.wrap_func(func, con, usb_port) + # ================================================================================================================== - @cmp.CProcess.register_signal(postfix="_finished") - def get_velocity(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(_con: LaserCon): - return _con.velocity + @CProperty + def acceleration(self): + return self._acceleration - return self.wrap_func(func, con, usb_port) + @acceleration.setter('acceleration_changed') + def acceleration(self, value: float): + self._acceleration = value - @cmp.CProcess.register_signal() - def get_acceleration(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(con: LaserCon): return con.acceleration + # ================================================================================================================== - return self.wrap_func(func, con, usb_port) + @CProperty + def deceleration(self): + return self._deceleration - @cmp.CProcess.register_signal(postfix="_finished") - def get_deceleration(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs) -> float: - def func(_con: LaserCon): - return _con.deceleration + @deceleration.setter('deceleration_changed') + def deceleration(self, value: float): + self._deceleration = value + + + + + + def read_current_wavelength(self) -> float: + if self.laser is None or self._connected is False: + self.current_wavelength = 0 + return -1 + else: + self.current_wavelength = float(self.laser.getWavelength()) + return self._current_wavelength + + + def read_min_wavelength(self) -> float: + if self.laser is None or self._connected is False: + self.min_wavelength = 0 + return -1 + else: + self.min_wavelength = float(self.laser.getWavelengthMinMax()[0]) + + return self._min_wavelength - return self.wrap_func(func, con, usb_port) + def read_max_wavelength(self) -> float: + if self.laser is None or self._connected is False: + self.max_wavelength = 0 + return -1 + else: + self.max_wavelength = float(self.laser.getWavelengthMinMax()[1]) + return self._max_wavelength + + def read_velocity(self) -> float: + if self.laser is None or self._connected is False: + self.velocity = 0 + return -1 + else: + self.velocity = float(self.laser.getVelocity()[0]) + return self._velocity + + def read_acceleration(self) -> float: + if self.laser is None or self._connected is False: + self.acceleration = 0 + return -1 + else: + self.acceleration = float(self.laser.getVelocity()[1]) + return self._acceleration - def read_laser_settings(self, con: LaserCon = None, usb_port: str = None, *args, **kwargs): + def read_deceleration(self) -> float: + if self.laser is None or self._connected is False: + self.deceleration = 0 + return -1 + else: + self.deceleration = float(self.laser.getVelocity()[2]) + return self._deceleration + + + def read_laser_settings(self, usb_port: str = None, *args, **kwargs): self.logger.info(f"Reading laser settings.") - def _read(con: LaserCon): - self.get_min_wavelength(con) - self.get_max_wavelength(con) - self.get_current_wavelength(con) - self.get_velocity(con) - self.get_acceleration(con) - self.get_deceleration(con) + self.read_current_wavelength() + self.read_min_wavelength() + self.read_max_wavelength() + self.read_velocity() + self.read_acceleration() + self.read_deceleration() - self.wrap_func(_read, con=con, usb_port=usb_port) @CProperty def laser_is_moving(self): @@ -147,6 +242,8 @@ class MPLaserDevice(cmp.CProcess): self.laser_moving_flag.value = int(value[0]) self._laser_moving = value + + @cmp.CProcess.register_signal(postfix="_changed") def movement_finished(self, finished: bool): self.laser_finished_flag.value = finished @@ -155,9 +252,13 @@ class MPLaserDevice(cmp.CProcess): @cmp.CProcess.register_signal(postfix="_finished") def move_to_wavelength(self, usb_port: str = None, wavelength: float = None, capture: bool = False, *args, **kwargs): - # laser_moving_flag.value = False - def _move(con: LaserCon): - self.read_laser_settings(con) + + if self.laser is None or self._connected is False: + return -1 + else: + + + self.read_laser_settings() self.laser_is_moving = (False, wavelength) self.laser_finished_flag.value = False self.logger.info(f"**** Go to selected wavelength. Started moving laser to {wavelength}. ****") @@ -169,7 +270,7 @@ class MPLaserDevice(cmp.CProcess): f"******************** Capture flag set to {self.start_capture_flag.value} **********************") time.sleep(1) - con.go_to_wvl(wavelength, False) + self.laser.moveToWavelength(wavelength, False) self.start_capture_flag.value = int(False) self._module_logger.info( f"******************** Capture flag set to {self.start_capture_flag.value} **********************") @@ -183,12 +284,11 @@ class MPLaserDevice(cmp.CProcess): # current_wavelength.value = con.current_wavelength self.logger.info( - f">>> Current Wavelength: {self.get_current_wavelength(con)}. Took {time_end - time_start} seconds to move.") - self.read_laser_settings(con) + f">>> Current Wavelength: {self.read_current_wavelength()}. Took {time_end - time_start} seconds to move.") + self.read_laser_settings() # laser_connected_flag.value = False # We need to manually set this - return self.get_current_wavelength(con) + return self.read_current_wavelength() - return self.wrap_func(_move, usb_port=usb_port) def wavelength_sweep(self, usb_port: str = None, wavelength_start: float = None, diff --git a/src/LaserControl/libs/EposCmd64.dll b/src/LaserControl/libs/EposCmd64.dll index cdbb785296cac8a211c4c7d936210070598e99de..6e281173baf9d75016d5ff7d02f04501f8edbacd 100644 Binary files a/src/LaserControl/libs/EposCmd64.dll and b/src/LaserControl/libs/EposCmd64.dll differ diff --git a/src/LaserControl/libs/EposCmd64.lib b/src/LaserControl/libs/EposCmd64.lib deleted file mode 100644 index dcd7f59e3d8174a3291a303989ef13ad2c1177ed..0000000000000000000000000000000000000000 Binary files a/src/LaserControl/libs/EposCmd64.lib and /dev/null differ diff --git a/src/LaserControl/libs/dc_motor.py b/src/LaserControl/libs/dc_motor.py deleted file mode 100644 index a12cd91626b83045164bf3c01eccbae8049421ee..0000000000000000000000000000000000000000 --- a/src/LaserControl/libs/dc_motor.py +++ /dev/null @@ -1,19 +0,0 @@ -import LaserLib as s -s.__doc__ -from LaserLib import * - -o=laserSacher() -o.connectMotor("USB0") - -current_wavelength= o.getCurrentWavelength() -vel = o.getVelocity() -o.setVelocity(2.0) -acc = o.getAcceleration() -o.setAcceleration(2.0) -print(">>>>>>>>>>>>>>>>>>>> Current Wavelength is:", current_wavelength) -print(">>>>>>>>>>>>>>>>>>>> vel:", vel) -print(">>>>>>>>>>>>>>>>>>>> acc:", acc) - -target_wavelength = float(input(">>>>>>>>>>>>>>>>>>>> Enter Target Wavelength in nm: ")) -o.goToWvl(target_wavelength, False) -o.closeMotorConnection() diff --git a/src/LaserControl/view/LaserControlView.py b/src/LaserControl/view/LaserControlView.py index 30f355e65439abd5d55b18e7afb5d7d0c54f3a95..36d6b6fcb3daf1f1582b1cc952e64db992999091 100644 --- a/src/LaserControl/view/LaserControlView.py +++ b/src/LaserControl/view/LaserControlView.py @@ -210,10 +210,10 @@ class LaserControlView(QMainWindow): def _on_btn_connect_clicked(self): if self.model.connected: self.logger.debug("Attempting to disconnect from laser") - self.controller.read_laser_settings() + #self.controller elif not self.model.connected: self.logger.debug(f"Attempting to connect to laser on port: {self.model.port}") - self.controller.read_laser_settings(usb_port=self.model.port) + self.controller.dev_connect(usb_port=self.model.port) def _on_btn_move_to_wavelength_clicked(self): self.logger.debug(f"Attempting to set wavelength to: {self._ui.sb_set_wavelength.value()}")