Accretech wafer prober driver

src/Temperature-Accretech_UFseries/libs/accretech_uf.py

@@ -26,18 +26,16 @@
 # SOFTWARE.
 
 
-# SweepMe! device class
-# Type: WaferProber
-# Device: Accretech UF series
-
 from __future__ import annotations
 
 import inspect
 from datetime import datetime
+import time
 
 import pysweepme.Ports
-from pysweepme.ErrorMessage import debug
+from pysweepme.ErrorMessage import debug, error
 from pyvisa import constants
+import pyvisa
 
 try:
     from pysweepme.UserInterface import get_input
@@ -182,10 +180,6 @@ def __init__(self, port: pysweepme.Ports.Port):
             "an error occurs in the driver software for the GPIB interface control on the prober side",
         }
 
-    def __del__(self) -> None:
-        """When the object is deleted, the SRQ event is unregistered."""
-        self.unregister_srq_event()
-
     def register_srq_event(self) -> None:
         """Register Service Request Events."""
         self.port.port.enable_event(self.event_type, self.event_mech)
@@ -215,7 +209,7 @@ def get_prober_status_message(self, prober_status: str) -> str:
 
     @staticmethod
     def get_waferlist_from_status(wafer_status: str) -> list[tuple[int, int]]:
-        """Returns a list of tuples with the cassette and wafer numbers."""
+        """Returns a list of tuples with cassette number, wafer number, and status value."""
         wafer_list = []
 
         # iterates through cassettes
@@ -227,7 +221,7 @@ def get_waferlist_from_status(wafer_status: str) -> list[tuple[int, int]]:
                 for wafer_id, val in enumerate(wafers):
                     if val != "0":
                         # adding a tuple of cassette and wafer number
-                        wafer_list.append((cassette_id + 1, wafer_id + 1))
+                        wafer_list.append((cassette_id + 1, wafer_id + 1, int(val)))
 
         return wafer_list
 
@@ -254,7 +248,8 @@ def wait_until_status_byte(self, stb_success: int | tuple, timeout: float = 5.0)
         stb = None
         while stb not in stb_success:
             stb = self.acquire_status_byte(timeout)
-
+            if stb == 99:  # Abnormal end always indicate that we can break here
+                break
         return stb
 
     def acquire_status_byte(self, timeout: float = 10.0) -> int:
@@ -275,7 +270,20 @@ def acquire_status_byte(self, timeout: float = 10.0) -> int:
                 print("-->", now.strftime("%H:%M:%S"), "Function:", function_calling_name)
 
         # Wait for the SRQ event to occur
-        response = self.port.port.wait_on_event(self.event_type, int(timeout * 1000))  # conversion from s to ms
+        # A while-loop is used to be able to stop the waiting for the event in future
+        starttime = time.time()
+        while True: 
+            if time.time()-starttime < timeout:
+                try:
+                    response = self.port.port.wait_on_event(self.event_type, int(1000))  # waiting 1000 ms
+                    break
+                except pyvisa.errors.VisaIOError:
+                    # Timeout error
+                    # Todo: figure out whether the VisIOError is a Timeout error
+                    pass
+            else:
+                msg = "Timeout reached during waiting for status byte"
+                raise Exception(msg)
 
         # The event mechanism was changed after pyvisa 1.9.0 and the WaitResponse structure is different
         if hasattr(response, "event"):
@@ -320,7 +328,8 @@ def acquire_status_byte(self, timeout: float = 10.0) -> int:
 
             while True:
                 msg = "Accretech: " + error_type + " (%s): " % error_code + error_message + " after status byte 76"
-                answer = get_input(msg + "\n\nDo you like to continue y/n?")
+                answer = get_input(msg + "\n\nTo continue please confirm with 'y' and then handle the problem at the "
+                                    "prober\nDo you like to continue y/n?")
 
                 if answer.lower() == "y":
                     # we call this function again to make sure a new status byte is retrieved
@@ -632,15 +641,15 @@ def unload(self) -> int:
             # 71
         """
         self.port.write("U")
-        return self.wait_until_status_byte(71, timeout=180.0)
+        return self.wait_until_status_byte(71, timeout=300.0)
 
     def unload_all_wafers(self) -> int:
         """Returns:
         int: status byte
             # 94
         """
         self.port.write("U0")
-        return self.wait_until_status_byte(94, timeout=30.0)
+        return self.wait_until_status_byte((71, 94), timeout=300.0)
 
     def unload_to_inspection_tray(self) -> int:
         """Returns:
@@ -651,7 +660,9 @@ def unload_to_inspection_tray(self) -> int:
         return self.wait_until_status_byte(71, timeout=120.0)
 
     def load_specified_wafer(self, cassette, slot) -> int:
-        """This command can be used to load a wafer from a cassette. It indirectly starts a lot process and is not used with 'start'.
+        """This command can be used to load a wafer from a cassette.
+
+        It indirectly starts a lot process and is not used with 'start'.
 
         You can terminate the lot process by using cassette = 9 and slot = 99
 
@@ -681,7 +692,7 @@ def load_specified_wafer(self, cassette, slot) -> int:
             raise Exception(msg)
 
         self.port.write("j2%i%02d" % (int(cassette), int(slot)))
-        return self.wait_until_status_byte((70, 94), timeout=600.0)
+        return self.wait_until_status_byte((70, 94), timeout=300.0)
 
     def preload_specified_wafer(self, cassette, slot) -> int:
         """This command ("j3") can be used to preload a wafer from a cassette to the subchuck.
@@ -745,6 +756,13 @@ def load_and_preload_specified_wafers(self, cassette, slot, preload_cassette, pr
         self.port.write("j4%i%02d%i%02d" % (int(cassette), int(slot), int(preload_cassette), int(preload_slot)))
         return self.wait_until_status_byte(70, timeout=300.0)
 
+    def enable_reexecution(self):
+        """
+        Enables the re-execution of a lot process.
+        """
+        self.port.write("ji")
+        return self.wait_until_status_byte((98, 99), timeout=60.0)
+
     def load_wafer_aligned(self) -> int:
         """Returns:
         int: status byte
@@ -1011,9 +1029,34 @@ def set_chuck_temperature(self, temperature: float) -> None:
             msg = f"Accretech UF series: Temperature must be between {min_temperature} and {max_temperature} °C."
             raise Exception(msg)
 
-        self.port.write("h" + str(int(temperature * 10)))
+        self.port.write("h%04d" % (temperature * 10))
         answer = self.wait_until_status_byte((93, 99))
 
         correct_status = 93
         if answer != correct_status:  # Abnormal end of command  # noqa: PLR2004
-            self.raise_error(answer)
+            self.raise_error(answer)
+
+    def request_device_name_list(self, storage="c"):
+        """Requests the list of names of saved device parameter sets
+
+        Args:
+            storage: str
+
+        Returns:
+            str: list of all available device parameter set names
+        """
+
+        answer = self.query("d" + storage)
+        return answer
+
+    def request_cassette_lock_status(self):
+        """Requests cassette lock status
+
+        Returns:
+            int:
+                0: cassette is in the unlock status
+                1: cassette is in the lock status
+        """
+
+        answer = self.query("cls")
+        return int(answer)

src/Temperature-Accretech_UFseries/main.py

@@ -25,14 +25,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-# SweepMe! device class
-# Type: Temperature
-# Device: Accretech UF series
+# SweepMe! driver
+# * Module: Temperature
+# * Instrument: Accretech UF series
+
 from __future__ import annotations
 
 import os
 
 from pysweepme.EmptyDeviceClass import EmptyDevice
+from pysweepme.ErrorMessage import debug
 from pysweepme.FolderManager import addFolderToPATH
 
 addFolderToPATH()
@@ -87,52 +89,70 @@ def __init__(self) -> None:
             "GPIB_EOLread": "\r\n",
         }
 
+        self.port_str = "undefined_port"
+
         self.verbosemode = True
 
     def set_GUIparameter(self) -> dict:  # noqa: N802
         """Set initial GUI parameters."""
         return {
             "SweepMode": ["None", "Temperature"],
             "TemperatureUnit": ["°C"],
+            "IdleTemperature": 30,
         }
 
     def get_GUIparameter(self, parameter: dict) -> None:  # noqa: N802
         """Handle SweepMe GUI parameters."""
-        self.units[0] = parameter["TemperatureUnit"]
         self.port_str = parameter["Port"]
+        self.units[0] = parameter["TemperatureUnit"]
+        self.idle_temperature = parameter["IdleTemperature"]
 
     def connect(self) -> None:
         """Connect to the device and handle multiple instances."""
-        # creating an AccretechProber instance that handles all communication
-        # TODO: Handle multiple instances/SRQ Events
-        # self.instance_key = f"Accretech_UF_{self.port_str}"
-        #
-        # if self.instance_key in self.device_communication:
-        #     self.port = self.device_communication[self.instance_key]
-        # else:
-        #     self.device_communication[self.instance_key] = self.port
 
+        # creating an AccretechProber instance that handles all communication
         self.prober = accretech_uf.AccretechProber(self.port)
-
         self.prober.set_verbose(self.verbosemode)
 
+        # This identifier must be equal with the identifier used by the WaferProber_Accretech_UFseries driver
+        self.unique_identifier = "Driver_Accretech_UFseries_" + self.port_str
+        if self.unique_identifier not in self.device_communication:
+            self.device_communication[self.unique_identifier] = None
+
     def disconnect(self) -> None:
         """Disconnect from the device."""
-        del self.prober  # this makes sure the event mechanism is disabled
+        if self.unique_identifier in self.device_communication:
+            self.prober.unregister_srq_event()  # this makes sure the event mechanism is disabled
+            del self.device_communication[self.unique_identifier]
+        del self.prober  
 
     def initialize(self) -> None:
         """Initialize the device."""
-        # TODO: Check
         self.prober.reset_alarm()
 
+    def deinitialize(self):
+        pass
+
+    def unconfigure(self):
+        if self.idle_temperature != "":
+            _, target_temperature = self.prober.request_chuck_temperature()
+            if target_temperature != float(self.idle_temperature):
+                self.prober.set_chuck_temperature(float(self.idle_temperature))
+            else:
+                debug("Idle temperature already set.")
+
     def apply(self) -> None:
         """Apply the given temperature."""
-        self.prober.set_chuck_temperature(self.value)
+        _, target_temperature = self.prober.request_chuck_temperature()
+        if target_temperature != float(self.value):
+            self.prober.set_chuck_temperature(self.value)
+        else:
+            debug("Target temperature already set.")
 
     def measure(self) -> None:
         """Measure the temperature."""
         # TODO: chuck_temperature or hot_chuck_temperature?
-        self.temperature, target_temperature = self.prober.get_temperature()
+        self.temperature, target_temperature = self.prober.request_chuck_temperature()
 
     def call(self) -> list[float]:
         """Return measured temperature to SweepMe GUI."""
@@ -142,5 +162,5 @@ def call(self) -> list[float]:
 
     def measure_temperature(self) -> float:
         """Measure the temperature."""
-        _temperature, _target_temperature = self.prober.get_temperature()
+        _temperature, _target_temperature = self.prober.request_chuck_temperature()
         return _temperature