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()}")