puda-drivers 0.0.4__tar.gz → 0.0.5__tar.gz

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: puda-drivers
-Version: 0.0.4
+Version: 0.0.5
 Summary: Hardware drivers for the PUDA platform.
 Project-URL: Homepage, https://github.com/zhao-bears/puda-drivers
 Project-URL: Issues, https://github.com/zhao-bears/puda-drivers/issues
@@ -56,13 +56,19 @@ from puda_drivers.move import GCodeController
 gantry = GCodeController(port_name="/dev/ttyACM0", feed=3000)
 gantry.connect()
 
+# Configure axis limits for safety (recommended)
+gantry.set_axis_limits("X", 0, 200)
+gantry.set_axis_limits("Y", -200, 0)
+gantry.set_axis_limits("Z", -100, 0)
+gantry.set_axis_limits("A", -180, 180)
+
 # Home the gantry
 gantry.home()
 
-# Move to absolute position
+# Move to absolute position (validated against limits)
 gantry.move_absolute(x=50.0, y=-100.0, z=-10.0)
 
-# Move relative to current position
+# Move relative to current position (validated after conversion to absolute)
 gantry.move_relative(x=20.0, y=-10.0)
 
 # Query current position
@@ -73,6 +79,8 @@ print(f"Current position: {position}")
 gantry.disconnect()
 ```
 
+**Axis Limits and Validation**: The `move_absolute()` and `move_relative()` methods automatically validate that target positions are within configured axis limits. If a position is outside the limits, a `ValueError` is raised before any movement is executed. Use `set_axis_limits()` to configure limits for each axis.
+
 ### Liquid Handling (Sartorius)
 
 ```python
@@ -134,6 +142,7 @@ pipette.disconnect()
   - Supports X, Y, Z, and A axes
   - Configurable feed rates
   - Position synchronization and homing
+  - Automatic axis limit validation for safe operation
 
 ### Liquid Handling
 
@@ -142,6 +151,38 @@ pipette.disconnect()
   - Tip attachment and ejection
   - Configurable speeds and volumes
 
+## Error Handling
+
+### Axis Limit Validation
+
+Both `move_absolute()` and `move_relative()` validate positions against configured axis limits before executing any movement. If a position is outside the limits, a `ValueError` is raised:
+
+```python
+from puda_drivers.move import GCodeController
+
+gantry = GCodeController(port_name="/dev/ttyACM0")
+gantry.connect()
+
+# Set axis limits
+gantry.set_axis_limits("X", 0, 200)
+gantry.set_axis_limits("Y", -200, 0)
+
+try:
+    # This will raise ValueError: Value 250 outside axis limits [0, 200]
+    gantry.move_absolute(x=250.0, y=-50.0)
+except ValueError as e:
+    print(f"Move rejected: {e}")
+
+# Relative moves are also validated after conversion to absolute positions
+try:
+    # If current X is 150, moving 100 more would exceed the limit
+    gantry.move_relative(x=100.0)
+except ValueError as e:
+    print(f"Move rejected: {e}")
+```
+
+Validation errors are automatically logged at the ERROR level before the exception is raised.
+
 ## Finding Serial Ports
 
 To discover available serial ports on your system:

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/README.md

@@ -36,13 +36,19 @@ from puda_drivers.move import GCodeController
 gantry = GCodeController(port_name="/dev/ttyACM0", feed=3000)
 gantry.connect()
 
+# Configure axis limits for safety (recommended)
+gantry.set_axis_limits("X", 0, 200)
+gantry.set_axis_limits("Y", -200, 0)
+gantry.set_axis_limits("Z", -100, 0)
+gantry.set_axis_limits("A", -180, 180)
+
 # Home the gantry
 gantry.home()
 
-# Move to absolute position
+# Move to absolute position (validated against limits)
 gantry.move_absolute(x=50.0, y=-100.0, z=-10.0)
 
-# Move relative to current position
+# Move relative to current position (validated after conversion to absolute)
 gantry.move_relative(x=20.0, y=-10.0)
 
 # Query current position
@@ -53,6 +59,8 @@ print(f"Current position: {position}")
 gantry.disconnect()
 ```
 
+**Axis Limits and Validation**: The `move_absolute()` and `move_relative()` methods automatically validate that target positions are within configured axis limits. If a position is outside the limits, a `ValueError` is raised before any movement is executed. Use `set_axis_limits()` to configure limits for each axis.
+
 ### Liquid Handling (Sartorius)
 
 ```python
@@ -114,6 +122,7 @@ pipette.disconnect()
   - Supports X, Y, Z, and A axes
   - Configurable feed rates
   - Position synchronization and homing
+  - Automatic axis limit validation for safe operation
 
 ### Liquid Handling
 
@@ -122,6 +131,38 @@ pipette.disconnect()
   - Tip attachment and ejection
   - Configurable speeds and volumes
 
+## Error Handling
+
+### Axis Limit Validation
+
+Both `move_absolute()` and `move_relative()` validate positions against configured axis limits before executing any movement. If a position is outside the limits, a `ValueError` is raised:
+
+```python
+from puda_drivers.move import GCodeController
+
+gantry = GCodeController(port_name="/dev/ttyACM0")
+gantry.connect()
+
+# Set axis limits
+gantry.set_axis_limits("X", 0, 200)
+gantry.set_axis_limits("Y", -200, 0)
+
+try:
+    # This will raise ValueError: Value 250 outside axis limits [0, 200]
+    gantry.move_absolute(x=250.0, y=-50.0)
+except ValueError as e:
+    print(f"Move rejected: {e}")
+
+# Relative moves are also validated after conversion to absolute positions
+try:
+    # If current X is 150, moving 100 more would exceed the limit
+    gantry.move_relative(x=100.0)
+except ValueError as e:
+    print(f"Move rejected: {e}")
+```
+
+Validation errors are automatically logged at the ERROR level before the exception is raised.
+
 ## Finding Serial Ports
 
 To discover available serial ports on your system:

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "puda-drivers"
-version = "0.0.4"
+version = "0.0.5"
 description = "Hardware drivers for the PUDA platform."
 readme = "README.md"
 authors = [

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/src/puda_drivers/core/serialcontroller.py

@@ -2,12 +2,12 @@
 Generic Serial Controller for communicating with devices over serial ports.
 """
 
-import serial
 import time
-import serial.tools.list_ports
 import logging
 from typing import Optional, List, Tuple
 from abc import ABC
+import serial
+import serial.tools.list_ports
 
 logger = logging.getLogger(__name__)
 
@@ -45,7 +45,7 @@ def list_serial_ports(filter_desc: Optional[str] = None) -> List[Tuple[str, str,
 
 class SerialController(ABC):
     DEFAULT_BAUDRATE = 9600
-    DEFAULT_TIMEOUT = 20  # seconds
+    DEFAULT_TIMEOUT = 30  # seconds
     POLL_INTERVAL = 0.1  # seconds
 
     def __init__(self, port_name, baudrate=DEFAULT_BAUDRATE, timeout=DEFAULT_TIMEOUT):
@@ -127,8 +127,8 @@ class SerialController(ABC):
         try:
             self._serial.reset_input_buffer()  # clear input buffer
             self._serial.reset_output_buffer()  # clear output buffer
-            self._serial.write(bytes(command, "utf-8"))
             self._serial.flush()
+            self._serial.write(bytes(command, "utf-8"))
 
         except serial.SerialTimeoutException as e:
             # Log the timeout error and return None as requested (no re-raise)

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/src/puda_drivers/move/gcode.py

@@ -55,7 +55,9 @@ class GCodeController(SerialController):
 
     DEFAULT_FEEDRATE = 3000  # mm/min
     MAX_FEEDRATE = 3000  # mm/min
+    MAX_Z_FEED_RATE = 1000 # mm/min
     TOLERANCE = 0.01  # tolerance for position sync in mm
+    SAFE_MOVE_HEIGHT = -5 # safe height for Z and A axes in mm
 
     PROTOCOL_TERMINATOR = "\r"
     VALID_AXES = "XYZA"
@@ -66,6 +68,7 @@ class GCodeController(SerialController):
         baudrate: int = SerialController.DEFAULT_BAUDRATE,
         timeout: int = SerialController.DEFAULT_TIMEOUT,
         feed: int = DEFAULT_FEEDRATE,
+        z_feed: int = MAX_Z_FEED_RATE,
     ):
         """
         Initialize the G-code controller.
@@ -87,13 +90,14 @@ class GCodeController(SerialController):
         )
 
         # Tracks internal position state
-        self.current_position: Dict[str, float] = {
+        self._current_position: Dict[str, float] = {
             "X": 0.0,
             "Y": 0.0,
             "Z": 0.0,
             "A": 0.0,
         }
         self._feed: int = feed
+        self._z_feed: int = z_feed
 
         # Initialize axis limits with default values
         self._axis_limits: Dict[str, AxisLimits] = {
@@ -151,6 +155,15 @@ class GCodeController(SerialController):
         """
         return f"{command}{self.PROTOCOL_TERMINATOR}"
 
+    def wait_for_move(self) -> None:
+        """
+        Wait for the current move to complete (M400 command).
+        
+        This sends the M400 command which waits for all moves in the queue to complete
+        before continuing. This ensures that position updates are accurate.
+        """
+        self.execute(self._build_command("M400"))
+
     def _validate_axis(self, axis: str) -> str:
         """
         Validate and normalize an axis name.
@@ -292,19 +305,19 @@ class GCodeController(SerialController):
             home_target = "All"
 
         self._logger.info("[%s] homing axis/axes: %s **", cmd, home_target)
-        self._send_command(self._build_command(cmd))
+        self.execute(self._build_command(cmd))
         self._logger.info("Homing of %s completed.", home_target)
 
         # Update internal position (optimistic zeroing)
         if axis:
-            self.current_position[axis] = 0.0
+            self._current_position[axis] = 0.0
         else:
-            for key in self.current_position:
-                self.current_position[key] = 0.0
+            for key in self._current_position:
+                self._current_position[key] = 0.0
 
         self._logger.debug(
             "Internal position updated (optimistically zeroed) to %s",
-            self.current_position,
+            self._current_position,
         )
 
     def move_absolute(
@@ -314,7 +327,7 @@ class GCodeController(SerialController):
         z: Optional[float] = None,
         a: Optional[float] = None,
         feed: Optional[int] = None,
-    ) -> None:
+    ) -> Dict[str, float]:
         """
         Move to an absolute position (G90 + G1 command).
 
@@ -331,17 +344,26 @@ class GCodeController(SerialController):
         # Validate positions before executing move
         self._validate_move_positions(x=x, y=y, z=z, a=a)
 
+        # Fill in missing axes with current positions
+        target_x = x if x is not None else self._current_position["X"]
+        target_y = y if y is not None else self._current_position["Y"]
+        target_z = z if z is not None else self._current_position["Z"]
+        target_a = a if a is not None else self._current_position["A"]
+
         feed_rate = feed if feed is not None else self._feed
         self._logger.info(
             "Preparing absolute move to X:%s, Y:%s, Z:%s, A:%s at F:%s",
-            x,
-            y,
-            z,
-            a,
+            target_x,
+            target_y,
+            target_z,
+            target_a,
             feed_rate,
         )
 
-        self._execute_move(x=x, y=y, z=z, a=a, feed=feed)
+        return self._execute_move(
+            position={"X": target_x, "Y": target_y, "Z": target_z, "A": target_a},
+            feed=feed_rate
+        )
 
     def move_relative(
         self,
@@ -350,7 +372,7 @@ class GCodeController(SerialController):
         z: Optional[float] = None,
         a: Optional[float] = None,
         feed: Optional[int] = None,
-    ) -> None:
+    ) -> Dict[str, float]:
         """
         Move relative to the current position (converted to absolute move internally).
 
@@ -374,133 +396,111 @@ class GCodeController(SerialController):
             feed_rate,
         )
 
-        # Convert relative movements to absolute positions
-        abs_x = (self.current_position["X"] + x) if x is not None else None
-        abs_y = (self.current_position["Y"] + y) if y is not None else None
-        abs_z = (self.current_position["Z"] + z) if z is not None else None
-        abs_a = (self.current_position["A"] + a) if a is not None else None
+        # Convert relative movements to absolute positions, filling in missing axes with current position
+        abs_x = (self._current_position["X"] + x) if x is not None else self._current_position["X"]
+        abs_y = (self._current_position["Y"] + y) if y is not None else self._current_position["Y"]
+        abs_z = (self._current_position["Z"] + z) if z is not None else self._current_position["Z"]
+        abs_a = (self._current_position["A"] + a) if a is not None else self._current_position["A"]
 
         # Validate absolute positions before executing move
         self._validate_move_positions(x=abs_x, y=abs_y, z=abs_z, a=abs_a)
 
-        self._execute_move(x=abs_x, y=abs_y, z=abs_z, a=abs_a, feed=feed)
+        return self._execute_move(
+            position={"X": abs_x, "Y": abs_y, "Z": abs_z, "A": abs_a},
+            feed=feed_rate
+        )
 
     def _execute_move(
         self,
-        x: Optional[float] = None,
-        y: Optional[float] = None,
-        z: Optional[float] = None,
-        a: Optional[float] = None,
-        feed: Optional[int] = None,
-    ) -> None:
+        position: Dict[str, float],
+        feed: int,
+    ) -> Dict[str, float]:
         """
         Internal helper for executing G1 move commands with safe movement pattern.
         All coordinates are treated as absolute positions.
 
         Safe move pattern:
         1. If X or Y movement is needed, first move Z to 0 (safe height)
-        2. Then move X, Y (and optionally A) to target
-        3. Finally move Z to target position (if specified)
+        2. Then move X, Y to target
+        3. Finally move Z and A back to original position (or target if specified)
 
         Args:
-            x: Absolute X position (optional)
-            y: Absolute Y position (optional)
-            z: Absolute Z position (optional)
-            a: Absolute A position (optional)
-            feed: Feed rate (optional)
-        """
-        # Calculate target positions (all absolute)
-        target_pos = self.current_position.copy()
-        has_x = x is not None
-        has_y = y is not None
-        has_z = z is not None
-        has_a = a is not None
-
-        if not (has_x or has_y or has_z or has_a):
+            position: Dictionary with absolute positions for X, Y, Z, A axes
+            feed: Feed rate for the move
+        """
+        # Check if any movement is needed
+        needs_x_move = abs(position["X"] - self._current_position["X"]) > self.TOLERANCE
+        needs_y_move = abs(position["Y"] - self._current_position["Y"]) > self.TOLERANCE
+        needs_z_move = abs(position["Z"] - self._current_position["Z"]) > self.TOLERANCE
+        needs_a_move = abs(position["A"] - self._current_position["A"]) > self.TOLERANCE
+
+        if not (needs_x_move or needs_y_move or needs_z_move or needs_a_move):
             self._logger.warning(
                 "Move command issued without any axis movement. Skipping transmission."
             )
             return
+        
+        if needs_z_move and needs_a_move:
+            self._logger.warning(
+                "Move command issued with both Z and A movement. This is not supported. Skipping transmission."
+            )
+            raise ValueError("Move command issued with both Z and A movement. This is not supported.")
 
-        # Set target positions (all absolute)
-        if has_x:
-            target_pos["X"] = x
-        if has_y:
-            target_pos["Y"] = y
-        if has_z:
-            target_pos["Z"] = z
-        if has_a:
-            target_pos["A"] = a
-
-        feed_rate = feed if feed is not None else self._feed
-        if feed_rate > self.MAX_FEEDRATE:
-            feed_rate = self.MAX_FEEDRATE
-
-        # Ensure absolute mode is active
-        self._send_command(self._build_command("G90"))
-
-        # Safe move pattern: Z to 0, then XY, then Z to target
-        needs_xy_move = has_x or has_y
-        current_z = self.current_position["Z"]
-        target_z = target_pos["Z"] if has_z else current_z
+        # Step 0: Ensure absolute mode is active
+        self.execute(self._build_command("G90"))
+        needs_xy_move = needs_x_move or needs_y_move
 
-        # Step 1: Move Z to safe height (0) if XY movement is needed and Z is not already at 0
-        if needs_xy_move and abs(current_z) > 0.001:  # Small tolerance for floating point
-            # Validate safe height (Z=0) is within limits
-            self._validate_move_positions(z=0.0)
+        # Step 1: Move Z and A to SAFE_MOVE_HEIGHT if XY movement is needed
+        if needs_xy_move:
             self._logger.info(
-                "Safe move: Raising Z to safe height (0) before XY movement"
+                "Safe move: Raising Z and A to safe height (%s) before XY movement", self.SAFE_MOVE_HEIGHT
             )
-            move_cmd = f"G1 Z0 F{feed_rate}"
-            self._send_command(self._build_command(move_cmd))
-            self.current_position["Z"] = 0.0
-            self._logger.debug("Z moved to safe height (0)")
-
-        # Step 2: Move X, Y (and optionally A) to target
-        if needs_xy_move or has_a:
+            move_cmd = f"G1 Z-5 A-5 F{self._z_feed}"
+            self.execute(self._build_command(move_cmd))
+            self.wait_for_move()
+            self._current_position["Z"] = self.SAFE_MOVE_HEIGHT
+            self._current_position["A"] = self.SAFE_MOVE_HEIGHT
+            self._logger.debug("Z and A moved to safe height (%s)", self.SAFE_MOVE_HEIGHT)
+
+        # Step 2: Move X, Y to target
+        if needs_xy_move:
             move_cmd = "G1"
-            if has_x:
-                move_cmd += f" X{target_pos['X']}"
-            if has_y:
-                move_cmd += f" Y{target_pos['Y']}"
-            if has_a:
-                move_cmd += f" A{target_pos['A']}"
-            move_cmd += f" F{feed_rate}"
+            if needs_x_move:
+                move_cmd += f" X{position['X']}"
+            if needs_y_move:
+                move_cmd += f" Y{position['Y']}"
+            move_cmd += f" F{feed}"
 
             self._logger.info("Executing XY move command: %s", move_cmd)
-            self._send_command(self._build_command(move_cmd))
+            self.execute(self._build_command(move_cmd))
+            self.wait_for_move()
 
             # Update position for moved axes
-            if has_x:
-                self.current_position["X"] = target_pos["X"]
-            if has_y:
-                self.current_position["Y"] = target_pos["Y"]
-            if has_a:
-                self.current_position["A"] = target_pos["A"]
-
-        # Step 3: Move Z to target position (if Z movement was requested)
-        if has_z:
-            z_needs_move = abs(target_z - (0.0 if needs_xy_move else current_z)) > 0.001
-            if z_needs_move:
-                move_cmd = f"G1 Z{target_z} F{feed_rate}"
-                
-                if needs_xy_move:
-                    self._logger.info(
-                        "Safe move: Lowering Z to target position: %s", target_z
-                    )
-                else:
-                    self._logger.info("Executing Z move command: %s", move_cmd)
-                
-                self._send_command(self._build_command(move_cmd))
-                self.current_position["Z"] = target_z
+            if needs_x_move:
+                self._current_position["X"] = position['X']
+            if needs_y_move:
+                self._current_position["Y"] = position['Y']
+
+        # Step 3: Move Z and A back to original position (or target if specified)
+        if needs_z_move:
+            move_cmd = f"G1 Z{position['Z']} F{self._z_feed}"
+            self.execute(self._build_command(move_cmd))
+            self._current_position["Z"] = position['Z']
+        elif needs_a_move:
+            move_cmd = f"G1 A{position['A']} F{self._z_feed}"
+            self.execute(self._build_command(move_cmd))
+            self._current_position["A"] = position['A']
+        self.wait_for_move()
 
         self._logger.info(
-            "Move complete. Final position: %s", self.current_position
+            "Move complete. Final position: %s", self._current_position
         )
-        self._logger.debug("New internal position: %s", self.current_position)
+        self._logger.debug("New internal position: %s", self._current_position)
 
-        # Post-move position synchronization check
+        # Step 4: Post-move position synchronization check
         self.sync_position()
+        
+        return self._current_position
 
     def query_position(self) -> Dict[str, float]:
         """
@@ -555,8 +555,8 @@ class GCodeController(SerialController):
         queried_position = self.query_position()
 
         if not queried_position:
-            self._logger.warning("Query position failed. Cannot synchronize.")
-            return False, self.current_position
+            self._logger.error("Query position failed. Cannot synchronize.")
+            raise ValueError("Query position failed. Cannot synchronize.")
 
         # Compare internal vs. queried position
         axis_keys = ["X", "Y", "Z", "A"]
@@ -564,36 +564,31 @@ class GCodeController(SerialController):
 
         for axis in axis_keys:
             if (
-                axis in self.current_position
+                axis in self._current_position
                 and axis in queried_position
-                and abs(self.current_position[axis] - queried_position[axis])
+                and abs(self._current_position[axis] - queried_position[axis])
                 > self.TOLERANCE
             ):
                 self._logger.warning(
                     "Position mismatch found on %s axis: Internal=%.3f, Queried=%.3f",
                     axis,
-                    self.current_position[axis],
+                    self._current_position[axis],
                     queried_position[axis],
                 )
                 adjustment_needed = True
             elif axis in queried_position:
                 # Update internal position with queried position if it differs slightly
-                self.current_position[axis] = queried_position[axis]
+                self._current_position[axis] = queried_position[axis]
 
         # Perform re-synchronization move if needed
         if adjustment_needed:
             self._logger.info(
-                "** DISCREPANCY DETECTED. Moving robot back to internal position: %s **",
-                self.current_position,
+                "** DISCREPANCY DETECTED. Moving robot to internal position: %s **",
+                self._current_position,
             )
 
             try:
-                target_x = self.current_position.get("X")
-                target_y = self.current_position.get("Y")
-                target_z = self.current_position.get("Z")
-                target_a = self.current_position.get("A")
-
-                self.move_absolute(x=target_x, y=target_y, z=target_z, a=target_a)
+                self.move_absolute(x=self._current_position["X"], y=self._current_position["Y"], z=self._current_position["Z"], a=self._current_position["A"])
                 self._logger.info("Synchronization move successfully completed.")
 
                 # Recursive call to verify position after move
@@ -609,7 +604,7 @@ class GCodeController(SerialController):
         else:
             self._logger.info("No adjustment was made.")
 
-        return adjustment_needed, self.current_position.copy()
+        return adjustment_needed, self._current_position.copy()
 
     def get_info(self) -> str:
         """
@@ -628,5 +623,5 @@ class GCodeController(SerialController):
         Returns:
             Dictionary containing the current internal position for all axes
         """
-        self._logger.debug("Returning internal position: %s", self.current_position)
-        return self.current_position.copy()
+        self._logger.debug("Returning internal position: %s", self._current_position)
+        return self._current_position.copy()

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/tests/example.py

@@ -7,14 +7,14 @@ Created on Wed Nov 19 15:29:02 2025
 
 
 # %%
+# import serial.tools.list_ports
 # ports = serial.tools.list_ports.comports()
 #
 # for port, desc, hwid in sorted(ports):
-# print("{}: {} [{}]".format(port, desc, hwid))
+#     print("{}: {} [{}]".format(port, desc, hwid))
 
 # %% Open connection
 import serial
-import serial.tools.list_ports
 import time
 
 qubot = serial.Serial("/dev/ttyACM0", 9600, dsrdtr=True)

puda_drivers-0.0.4/tests/sartorius.py → puda_drivers-0.0.5/tests/pipette.py

@@ -1,7 +1,7 @@
 import logging
 from puda_drivers.transfer.liquid.sartorius import SartoriusController
 
-# Optinal: finding ports
+# Optional: finding ports
 # import serial.tools.list_ports
 # for port, desc, hwid in serial.tools.list_ports.comports():
 #     print(f"{port}: {desc} [{hwid}]")
@@ -26,57 +26,56 @@ TIP_LENGTH = 70  # mm
 
 
 # --- TEST FUNCTION ---
-def test_sartorius_operations():
+def test_pipette_operations():
     """
     Tests the initialization and core liquid handling functions
-    of the SartoriusController mock class.
+    of the SartoriusController.
     """
-    print("--- 🔬 Starting Sartorius Controller Test ---")
-    sartorius = SartoriusController(port_name=SARTORIUS_PORT)
+    print("--- 🔬 Starting Pipette Controller Test ---")
+    pipette = SartoriusController(port_name=SARTORIUS_PORT)
 
     try:
         # 1. Initialize and Connect
         print("\n[STEP 1] Connecting to pipette...")
-        sartorius.connect()
+        # SartoriusController connects automatically in __init__, no need to call connect()
+        
+        # Always start with initializing
+        pipette.initialize()
 
-        # # 2. Attach Tip
-        # print("\n[STEP 2] Initialize...")
-        # sartorius.initialize()
-
-        sartorius.get_inward_speed()
+        pipette.get_inward_speed()
         # print("\n set inward speed to 3")
-        # sartorius.set_inward_speed(3)
+        # pipette.set_inward_speed(3)
 
         # 3. Eject Tip (if any)
         # print("\n[STEP 3] Ejecting Tip (if any)...")
-        # sartorius.eject_tip(return_position=30)
+        # pipette.eject_tip(return_position=30)
         # print(f"\n[STEP 3] Aspirate {TRANSFER_VOLUME} uL...")
-        # sartorius.aspirate(amount=TRANSFER_VOLUME)
+        # pipette.aspirate(amount=TRANSFER_VOLUME)
 
         # 4. Dispense
         # print(f"\n[STEP 4] Dispensing {TRANSFER_VOLUME} uL...")
-        # sartorius.dispense(amount=TRANSFER_VOLUME)
+        # pipette.dispense(amount=TRANSFER_VOLUME)
 
         # # 5. Eject Tip
         # print("\n[STEP 5] Ejecting Tip...")
-        # sartorius.eject()
-        # if not sartorius.is_tip_on():
+        # pipette.eject()
+        # if not pipette.is_tip_on():
         #     print("✅ Tip check: Tip is ejected.")
         # else:
         #     raise Exception("Tip ejection failed.")
         #
-        # print("\n--- 🎉 All Sartorius operations passed! ---")
+        # print("\n--- 🎉 All Pipette operations passed! ---")
 
     except Exception as e:
         print(f"\n--- ❌ TEST FAILURE: {e} ---")
 
     finally:
         # 6. Disconnect
-        if sartorius and sartorius.is_connected:
+        if pipette and pipette.is_connected:
             print("\n[FINAL] Disconnecting...")
-            sartorius.disconnect()
-        print("--- 🧪 Sartorius Controller Test Complete ---")
+            pipette.disconnect()
+        print("--- 🧪 Pipette Controller Test Complete ---")
 
 
 if __name__ == "__main__":
-    test_sartorius_operations()
+    test_pipette_operations()

puda_drivers-0.0.5/tests/qubot.py

@@ -0,0 +1,109 @@
+import logging
+from puda_drivers.move import GCodeController
+
+# Optinal: finding ports
+import serial.tools.list_ports
+for port, desc, hwid in serial.tools.list_ports.comports():
+    print(f"{port}: {desc} [{hwid}]")
+
+# 1. Configure the root logger
+# All loggers in imported modules (SerialController, GCodeController) will inherit this setup.
+logging.basicConfig(
+    # Use logging.DEBUG to see all (DEBUG, INFO, WARNING, ERROR, CRITICAL) logs
+    level=logging.WARNING,
+    # Recommended format: includes time, logger name, level, and message
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
+# 2. OPTIONAL: If you only want GCodeController's logs at specific level, you can specifically set it here
+# logging.getLogger('puda_drivers.gcodecontroller').setLevel(logging.INFO)
+
+PORT_NAME = "/dev/ttyACM0"
+
+
+def main():
+    print("--- Starting GCode Controller Application ---")
+
+    try:
+        # Instantiate the qubot controller
+        qubot = GCodeController(port_name=PORT_NAME)
+
+        # Example: Set custom axis limits
+        qubot.set_axis_limits("X", 0, 330)
+        qubot.set_axis_limits("Y", -440, 0)
+        qubot.set_axis_limits("Z", -175, 0)
+        qubot.set_axis_limits("A", -175, 0)
+
+        # # Example: Get current axis limits
+        # print("\n--- Current Axis Limits ---")
+        # all_limits = qubot.get_axis_limits()
+        # for axis, limits in all_limits.items():
+        #     print(f"{axis}: [{limits.min}, {limits.max}]")
+
+        # # Example: Get limits for a specific axis
+        # x_limits = qubot.get_axis_limits("X")
+        # print(f"\nX axis limits: [{x_limits.min}, {x_limits.max}]")
+
+        # qubot.query_position()
+        # Always start with homing
+        print("\n")
+        qubot.home()
+
+        # # Setting feed rate (aka move speed) 
+        # # Should generate WARNING due to exceeding MAX_FEEDRATE (3000)
+        # qubot.feed = 5000
+
+        # Relative moves are converted to absolute internally, but works the same
+        # for anything in the Z-axis, will have to be moved individually, else error will be raised
+        print("\n")
+        qubot.move_absolute(x=00.0, y=-50.0, a=-100.0)
+        
+        # print("\n")
+        # qubot.move_relative(x=10.0)
+        
+        # Example stepping code
+        # for _ in range(10):
+        #     pos = qubot.move_relative(x=10.0)
+        #     print(f"Position: {pos}")
+        
+        # sync position isalways called after move, but in case if needed you can call it manually
+        # qubot.sync_position()
+
+        # print("\n")
+        # qubot.move_absolute(x=330.0, y=-440.0, z=-175.0)
+
+        # print("\n")
+        # qubot.sync_position()
+        # Example of an ERROR - invalid axis
+        # try:
+        #     qubot.home(axis="B")  # Generates ERROR
+        # except ValueError:
+        #     pass
+
+        # Example of an ERROR - position outside limits
+        # This will raise ValueError because x=250 is outside the X limits [0, 200]
+        # try:
+        #     qubot.move_absolute(x=250.0)  # Raises ValueError if outside limits
+        # except ValueError as e:
+        #     print(f"Position validation error (expected): {e}")
+        
+        # Example of relative move that would exceed limits
+        # This will raise ValueError if the resulting absolute position is outside limits
+        # try:
+        #     qubot.move_relative(x=300.0)  # If current X + 300 > 200, raises ValueError
+        # except ValueError as e:
+        #     print(f"Position validation error (expected): {e}")
+        
+        # Example of an ERROR - simultaneous Z and A movement
+        # This will raise ValueError because Z and A cannot move at the same time
+        # try:
+        #     qubot.move_absolute(z=-10.0, a=-20.0)  # Raises ValueError if both Z and A are moved
+        # except ValueError as e:
+        #     print(f"Z/A simultaneous movement error (expected): {e}")
+
+    except Exception as e:
+        logging.getLogger(__name__).error("An unrecoverable error occurred: %s", e)
+
+
+if __name__ == "__main__":
+    main()

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/tests/together.py

@@ -1,7 +1,14 @@
+import logging
 import serial
 from puda_drivers.move import GCodeController
 from puda_drivers.transfer.liquid.sartorius import SartoriusController
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,  # Use INFO level for cleaner output during automation
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+
 # Qubot Configuration
 QUBOT_PORT = "/dev/ttyACM0"
 QUBOT_BAUDRATE = 9600
@@ -14,12 +21,12 @@ TIP_LENGTH = 70  # mm
 
 # Define mock coordinates (assuming the Qubot operating space is in mm)
 # Note: These coordinates must be within the axis limits set below
-ASPIRATE_POS = {"X": 50.0, "Y": -50.0, "Z": -20.0, "A": -20.0}  # Source well location
+ASPIRATE_POS = {"X": 50.0, "Y": -50.0, "Z": -20.0, "A": 0.0}  # Source well location
 DISPENSE_POS = {
     "X": 80.0,
     "Y": -80.0,
     "Z": -20.0,
-    "A": -20.0,
+    "A": 0.0,
 }  # Destination well location
 SAFE_Z_POS = -10.0  # High Z position to prevent collisions (within Z limits)
 
@@ -29,10 +36,10 @@ pipette = None
 # 1. Initialize and Connect Qubot
 try:
     print("Connecting to qubot")
+    # GCodeController connects automatically in __init__, no need to call connect()
     qubot = GCodeController(
         port_name=QUBOT_PORT, baudrate=QUBOT_BAUDRATE, feed=QUBOT_FEEDRATE
     )
-    qubot.connect()
     
     # Set axis limits to accommodate the automation coordinates
     # Adjust these based on your actual hardware limits
@@ -46,6 +53,7 @@ try:
     for axis, limits in all_limits.items():
         print(f"  {axis}: [{limits.min}, {limits.max}]")
     
+    # Always start with homing
     qubot.home()
 except (IOError, ValueError, serial.SerialException) as e:
     print(f"FATAL ERROR: Could not connect to Qubot GCode Controller: \n{e}")
@@ -55,10 +63,8 @@ except Exception as e:
 # 2. Initialize and Connect the Liquid Handler (Sartorius)
 try:
     print("Connecting to pipette")
-    # The Sartorius class must be initialized with a port,
-    # so we'll simulate the connection for demonstration.
+    # SartoriusController connects automatically in __init__, no need to call connect()
     pipette = SartoriusController(port_name=SARTORIUS_PORT)
-    pipette.connect()
     pipette.initialize()
 except Exception as e:
     print(f"FATAL ERROR: Could not initialize/connect Sartorius: {e}")
@@ -78,21 +84,24 @@ def run_automation():
         print("Protocol Step 1: Attaching Tip")
         # Simulate moving to a tip rack position and attaching a tip
         print("Moving to Tip Rack and Attaching Tip...")
-        qubot.move_absolute(x=10.0, y=-10.0, z=-10.0, feed=3000)
+        pos = qubot.move_absolute(x=50.0, y=-50.0, z=-50.0, feed=3000)
+        print(f"  Position after move: {pos}")
 
         # 4. Protocol Step 2: Aspirate Liquid
         print(f"\nProtocol Step 2: Aspirating {TRANSFER_VOLUME} uL")
 
         # Move to safe Z-height before moving across the deck
-        qubot.move_absolute(z=SAFE_Z_POS)
+        pos = qubot.move_absolute(z=SAFE_Z_POS)
+        print(f"  Position after safe Z move: {pos}")
 
         # Move to the source well (ASPIRATE_POS)
-        qubot.move_absolute(
+        pos = qubot.move_absolute(
             x=ASPIRATE_POS["X"], y=ASPIRATE_POS["Y"], z=ASPIRATE_POS["Z"], feed=3000
         )
+        print(f"  Position at source well: {pos}")
 
         # Lower the tip to the aspiration depth using A axis for height
-        qubot.move_absolute(a=ASPIRATE_POS["A"])
+        print(f"  Position at aspiration depth: {pos}")
 
         # Perform aspiration
         pipette.aspirate(amount=TRANSFER_VOLUME)
@@ -101,27 +110,32 @@ def run_automation():
         print(f"\nProtocol Step 3: Dispensing {TRANSFER_VOLUME} uL")
 
         # Move to safe Z-height again
-        qubot.move_absolute(z=SAFE_Z_POS)
+        pos = qubot.move_absolute(z=SAFE_Z_POS)
+        print(f"  Position after safe Z move: {pos}")
 
         # Move to the destination well (DISPENSE_POS)
-        qubot.move_absolute(
+        pos = qubot.move_absolute(
             x=DISPENSE_POS["X"], y=DISPENSE_POS["Y"], z=DISPENSE_POS["Z"], feed=3000
         )
+        print(f"  Position at destination well: {pos}")
 
         # Lower the tip to the dispensing depth using A axis for height
-        qubot.move_absolute(a=DISPENSE_POS["A"])
+        pos = qubot.move_absolute(a=DISPENSE_POS["A"])
+        print(f"  Position at dispensing depth: {pos}")
 
         # Perform dispensing
-        pipette.dispense(amount=50)
+        pipette.dispense(amount=TRANSFER_VOLUME)
 
         # 6. Protocol Step 4: Finalization
         print("\nProtocol Step 4: Finalizing")
 
         # Move back to safe Z-height
-        qubot.move_absolute(z=SAFE_Z_POS)
+        pos = qubot.move_absolute(z=SAFE_Z_POS)
+        print(f"  Position after safe Z move: {pos}")
 
         # Simulate moving to a trash bin and ejecting the tip
-        qubot.move_absolute(x=10.0, y=-10.0)
+        pos = qubot.move_absolute(x=10.0, y=-10.0)
+        print(f"  Position at trash bin: {pos}")
         pipette.eject_tip()
 
     except Exception as e:

{puda_drivers-0.0.4 → puda_drivers-0.0.5}/uv.lock

@@ -9,7 +9,7 @@ resolution-markers = [
 
 [[package]]
 name = "puda-drivers"
-version = "0.0.4"
+version = "0.0.5"
 source = { editable = "." }
 dependencies = [
     { name = "pyserial" },

puda_drivers-0.0.4/tests/qubot.py

@@ -1,77 +0,0 @@
-import logging
-from puda_drivers.move import GCodeController
-
-# Optinal: finding ports
-# import serial.tools.list_ports
-# for port, desc, hwid in serial.tools.list_ports.comports():
-#     print(f"{port}: {desc} [{hwid}]")
-
-# 1. Configure the root logger
-# All loggers in imported modules (SerialController, GCodeController) will inherit this setup.
-logging.basicConfig(
-    # Use logging.DEBUG to see all (DEBUG, INFO, WARNING, ERROR, CRITICAL) logs
-    level=logging.DEBUG,
-    # Recommended format: includes time, logger name, level, and message
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-
-# 2. OPTIONAL: If you only want GCodeController's logs at specific level, you can specifically set it here
-# logging.getLogger('drivers.gcodecontroller').setLevel(logging.INFO)
-
-PORT_NAME = "/dev/ttyACM1"
-
-
-def main():
-    print("--- Starting GCode Controller Application ---")
-
-    try:
-        # Instantiate the qubot controller
-        qubot = GCodeController(port_name=PORT_NAME)
-
-        # Example: Get current axis limits
-        print("\n--- Current Axis Limits ---")
-        all_limits = qubot.get_axis_limits()
-        for axis, limits in all_limits.items():
-            print(f"{axis}: [{limits.min}, {limits.max}]")
-
-        # Example: Get limits for a specific axis
-        x_limits = qubot.get_axis_limits("X")
-        print(f"\nX axis limits: [{x_limits.min}, {x_limits.max}]")
-
-        # Example: Set custom axis limits
-        qubot.set_axis_limits("X", -200, 200)
-        qubot.set_axis_limits("Y", -200, 200)
-        qubot.set_axis_limits("Z", -100, 100)
-        qubot.set_axis_limits("A", -180, 180)
-
-        qubot.query_position()
-        # Always start with homing
-        qubot.home()
-        qubot.sync_position()
-
-        # Should generate WARNING due to exceeding MAX_FEEDRATE (3000)
-        # qubot.feed = 5000
-
-        # Relative moves are converted to absolute internally, but works the same
-        # qubot.move_relative(x=20.0, y=-10.0)
-        #
-        # qubot.move_absolute(x=50.0, y=-50.0, z=-10.0)
-
-        # Example of an ERROR - invalid axis
-        # try:
-        #     qubot.home(axis="B")  # Generates ERROR
-        # except ValueError:
-        #     pass
-
-        # Example of an ERROR - position outside limits
-        # try:
-        #     qubot.move_absolute(x=150.0)  # May raise ValueError if outside limits
-        # except ValueError as e:
-        #     print(f"Position validation error: {e}")
-
-    except Exception as e:
-        logging.getLogger(__name__).error(f"An unrecoverable error occurred: {e}")
-
-
-if __name__ == "__main__":
-    main()