puda-drivers 0.0.14__tar.gz → 0.0.16__tar.gz

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: puda-drivers
-Version: 0.0.14
+Version: 0.0.16
 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

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/pyproject.toml

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

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/src/puda_drivers/core/serialcontroller.py

@@ -4,6 +4,7 @@ Generic Serial Controller for communicating with devices over serial ports.
 
 import time
 import logging
+import threading
 from typing import Optional, List, Tuple
 from abc import ABC, abstractmethod
 import serial
@@ -49,6 +50,9 @@ class SerialController(ABC):
         self.baudrate = baudrate
         self.timeout = timeout
         self._logger = logger
+        
+        # lock to prevent concurrent access to the serial port
+        self._lock = threading.Lock()
 
     def connect(self) -> None:
         """
@@ -103,8 +107,9 @@ class SerialController(ABC):
 
     def _send_command(self, command: str) -> None:
         """
-        Sends a custom protocol command, reads, and returns the response.
-        If a timeout occurs, it logs the error and returns None instead of raising an exception.
+        Sends a custom protocol command.
+        Note: This method should be called while holding self._lock to ensure
+        atomic command/response pairing.
         """
         if not self.is_connected or not self._serial:
             self._logger.error(
@@ -116,7 +121,6 @@ class SerialController(ABC):
 
         self._logger.info("-> Sending: %r", command)
 
-        # Send the command
         try:
             self._serial.reset_input_buffer()  # clear input buffer
             self._serial.reset_output_buffer()  # clear output buffer
@@ -130,7 +134,7 @@ class SerialController(ABC):
 
         except serial.SerialException as e:
             self._logger.error(
-                "Serial error writing or reading command '%s'. Error: %s",
+                "Serial error writing command '%s'. Error: %s",
                 command,
                 e,
             )
@@ -198,11 +202,14 @@ class SerialController(ABC):
         
         This method combines sending a command and reading its response into a
         single atomic operation, ensuring the response corresponds to the command
-        that was just sent. This is the preferred method for commands that
-        require a response.
+        that was just sent. The entire operation is protected by a lock to prevent
+        concurrent commands from interfering with each other.
+        
+        This is the preferred method for commands that require a response.
         
         Args:
             command: Command string to send (should include protocol terminator if needed)
+            value: Optional value parameter for the command
             
         Returns:
             Response string from the device
@@ -211,20 +218,22 @@ class SerialController(ABC):
             serial.SerialException: If device is not connected or communication fails
             serial.SerialTimeoutException: If no response is received within timeout
         """
-        self._send_command(self._build_command(command, value))
-        
-        # Increase timeout by 60 seconds for G28 (homing) command
-        original_timeout = self.timeout
-        if "G28" in command.upper():
-            self.timeout = original_timeout + 60
-            # Also update the serial connection's timeout if connected
-            if self.is_connected and self._serial:
-                self._serial.timeout = self.timeout
-        
-        try:
-            return self._read_response()
-        finally:
-            # Restore original timeout
-            self.timeout = original_timeout
-            if self.is_connected and self._serial:
-                self._serial.timeout = original_timeout
+        # Hold the lock for the entire send+read operation to ensure atomicity
+        # This prevents concurrent commands from mixing up responses
+        with self._lock:
+            # Increase timeout by 60 seconds for G28 (homing) command
+            original_timeout = self.timeout
+            if "G28" in command.upper():
+                self.timeout = original_timeout + 60
+                # Also update the serial connection's timeout if connected
+                if self.is_connected and self._serial:
+                    self._serial.timeout = self.timeout
+            
+            try:
+                self._send_command(self._build_command(command, value))
+                return self._read_response()
+            finally:
+                # Restore original timeout
+                self.timeout = original_timeout
+                if self.is_connected and self._serial:
+                    self._serial.timeout = original_timeout

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/src/puda_drivers/machines/first.py

@@ -159,7 +159,7 @@ class First:
         self.camera.disconnect()
         self._logger.info("Machine shutdown complete")
         
-    def get_position(self) -> Dict[str, float]:
+    async def get_position(self) -> Dict[str, Union[Dict[str, float], int]]:
         """
         Get the current position of the machine. Both QuBot and Sartorius are queried.
         
@@ -168,8 +168,8 @@ class First:
         Returns:
             Dictionary containing the current position of the machine and it's components.
         """
-        qubot_position = self.qubot.get_position()
-        sartorius_position = self.pipette.get_position()
+        qubot_position = await self.qubot.get_position()
+        sartorius_position = await self.pipette.get_position()
 
         return {
             "qubot": qubot_position.to_dict(),
@@ -234,7 +234,11 @@ class First:
         self.qubot.move_absolute(position=pos)
         
         # attach tip (move slowly down)
-        insert_depth = self.deck[slot].get_insert_depth()
+        labware = self.deck[slot]
+        if labware is None:
+            self._logger.error("Cannot attach tip: no labware loaded in slot '%s'", slot)
+            raise ValueError(f"No labware loaded in slot '{slot}'. Load labware before attaching tips.")
+        insert_depth = labware.get_insert_depth()
         self._logger.debug("Moving down by %s mm to insert tip", insert_depth)
         self.qubot.move_relative(
             position=Position(z=-insert_depth),
@@ -378,17 +382,24 @@ class First:
             
         Returns:
             Position with absolute coordinates
+            
+        Raises:
+            ValueError: If well is specified but no labware is loaded in the slot
         """
         # Get slot origin
         pos = self.get_slot_origin(slot)
 
         # relative well position from slot origin
         if well:
-            well_pos = self.deck[slot].get_well_position(well).get_xy()
+            labware = self.deck[slot]
+            if labware is None:
+                self._logger.error("Cannot get well position: no labware loaded in slot '%s'", slot)
+                raise ValueError(f"No labware loaded in slot '{slot}'. Load labware before accessing wells.")
+            well_pos = labware.get_well_position(well).get_xy()
             # the deck is rotated 90 degrees clockwise for this machine
             pos += well_pos.swap_xy()
             # get z
-            pos += Position(z=self.deck[slot].get_height() - self.CEILING_HEIGHT)
+            pos += Position(z=labware.get_height() - self.CEILING_HEIGHT)
             self._logger.debug("Absolute Z position for slot '%s', well '%s': %s", slot, well, pos)
         else:
             self._logger.debug("Absolute Z position for slot '%s': %s", slot, pos)
@@ -404,15 +415,22 @@ class First:
             
         Returns:
             Position with absolute coordinates
+            
+        Raises:
+            ValueError: If well is specified but no labware is loaded in the slot
         """
         pos = self.get_slot_origin(slot)
         
         if well:
-            well_pos = self.deck[slot].get_well_position(well).get_xy()
+            labware = self.deck[slot]
+            if labware is None:
+                self._logger.error("Cannot get well position: no labware loaded in slot '%s'", slot)
+                raise ValueError(f"No labware loaded in slot '{slot}'. Load labware before accessing wells.")
+            well_pos = labware.get_well_position(well).get_xy()
             pos += well_pos.swap_xy()
             
             # get a
-            a = Position(a=self.deck[slot].get_height() - self.CEILING_HEIGHT)
+            a = Position(a=labware.get_height() - self.CEILING_HEIGHT)
             pos += a
             self._logger.debug("Absolute A position for slot '%s', well '%s': %s", slot, well, pos)
         else:

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/src/puda_drivers/move/gcode.py

@@ -7,9 +7,9 @@ absolute coordinates, with relative moves converted to absolute internally.
 Supports homing and position synchronization.
 """
 
-import time
 import re
 import logging
+import asyncio
 from dataclasses import dataclass
 from typing import Optional, Dict, Tuple, Union
 
@@ -508,9 +508,15 @@ class GCodeController(SerialController):
         
         return self._current_position
 
-    def get_position(self) -> Position:
+    async def get_position(self) -> Position:
         """
-        Get the current machine position (M114 command).
+        Get the current machine position (M114 command) asynchronously.
+
+        This method can be called even when the machine is moving from other commands,
+        as it runs the blocking serial communication in a separate thread.
+        
+        If the M114 command takes more than 1 second to respond, falls back to
+        returning the internally tracked position instead.
 
         Returns:
             Position containing X, Y, Z, and A positions
@@ -519,28 +525,39 @@ class GCodeController(SerialController):
             Returns an empty Position if the query fails or no positions are found.
         """
         self._logger.info("Querying current machine position (M114).")
-        res: str = self.execute("M114")
-
-        # Extract position values using regex
-        pattern = re.compile(r"([XYZA]):(-?\d+\.\d+)")
-        matches = pattern.findall(res)
-
-        position_data: Dict[str, float] = {}
+        # Run the blocking execute call in a thread pool to allow concurrent operations
+        # with a 1 second timeout - if it takes longer, fall back to internal position
+        try:
+            res: str = await asyncio.wait_for(
+                asyncio.to_thread(self.execute, "M114"),
+                timeout=1.0
+            )
+            
+            # Extract position values using regex
+            pattern = re.compile(r"([XYZA]):(-?\d+\.\d+)")
+            matches = pattern.findall(res)
 
-        for axis, value_str in matches:
-            try:
-                position_data[axis.lower()] = float(value_str)
-            except ValueError:
-                self._logger.error(
-                    "Failed to convert position value '%s' for axis %s to float.",
-                    value_str,
-                    axis,
-                )
-                continue
+            position_data: Dict[str, float] = {}
 
-        position = Position.from_dict(position_data)
-        self._logger.info("Query position complete. Retrieved positions: %s", position)
-        return position
+            for axis, value_str in matches:
+                try:
+                    position_data[axis.lower()] = float(value_str)
+                except ValueError:
+                    self._logger.error(
+                        "Failed to convert position value '%s' for axis %s to float.",
+                        value_str,
+                        axis,
+                    )
+                    continue
+
+            position = Position.from_dict(position_data)
+            self._logger.info("Query position complete. Retrieved positions: %s", position)
+            return position
+        except asyncio.TimeoutError:
+            self._logger.warning(
+                "M114 command timed out after 1 second. Falling back to internal position."
+            )
+            return self.get_internal_position()
 
     def _sync_position(self) -> Tuple[bool, Position]:
         """
@@ -556,11 +573,13 @@ class GCodeController(SerialController):
 
         Note:
             This method may recursively call itself if a correction move is made.
+            Since this method calls move_absolute (which is blocking), it remains
+            synchronous. The async get_position() is called using asyncio.run().
         """
         self._logger.info("Starting position synchronization check (M114).")
 
-        # Query the actual machine position
-        queried_position = self.get_position()
+        # Query the actual machine position (async method called from sync context)
+        queried_position = asyncio.run(self.get_position())
 
         if not queried_position.get_axes():
             self._logger.error("Query position failed. Cannot synchronize.")

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/src/puda_drivers/transfer/liquid/sartorius/rLine.py

@@ -9,14 +9,13 @@ Reference: https://api.sartorius.com/document-hub/dam/download/34901/Sartorius-r
 
 import json
 import logging
+import asyncio
 from typing import Optional
 from puda_drivers.core.serialcontroller import SerialController
 from .constants import STATUS_CODES
 
 class SartoriusDeviceError(Exception):
     """Custom exception raised when the Sartorius device reports an error."""
-    
-    pass
 
 class SartoriusController(SerialController):
     """
@@ -372,15 +371,19 @@ class SartoriusController(SerialController):
 
         return json.dumps(status_data)
     
-    def get_position(self) -> int:
+    async def get_position(self) -> int:
         """
-        Query the current position of the pipette (DP command).
+        Query the current position of the pipette (DP command) asynchronously.
+
+        This method can be called even when the pipette is performing other operations,
+        as it runs the blocking serial communication in a separate thread.
 
         Returns:
             Current position in steps
         """
         self._logger.info("** Querying Position (DP) **")
-        response = self.execute(command="DP")
+        # Run the blocking execute call in a thread pool to allow concurrent operations
+        response = await asyncio.to_thread(self.execute, command="DP")
         self._logger.info("** Position: %s steps **\n", response)
         return response
     

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/tests/pipette.py

@@ -1,4 +1,5 @@
 import logging
+import asyncio
 from puda_drivers.transfer.liquid.sartorius import SartoriusController
 from puda_drivers.core.logging import setup_logging
 
@@ -52,7 +53,7 @@ def test_pipette_operations():
         pipette.set_outward_speed(3)
         pipette.get_outward_speed()
         pipette.run_to_position(100)
-        pipette.get_position()
+        asyncio.run(pipette.get_position())
 
         # 3. Eject Tip (if any)
         print("[STEP 3] Ejecting Tip (if any)...")

puda_drivers-0.0.16/tests/test_position_polling.py

@@ -0,0 +1,115 @@
+"""Test script to poll get_position every second during machine operations."""
+
+import asyncio
+import json
+import logging
+from datetime import datetime
+from puda_drivers.machines import First
+from puda_drivers.labware import get_available_labware
+from puda_drivers.core import setup_logging
+
+setup_logging(
+    enable_file_logging=False,
+    log_level=logging.INFO,
+)
+
+
+async def poll_position(machine: First, stop_event: asyncio.Event):
+    """
+    Poll get_position every second and print the results.
+    
+    Args:
+        machine: First machine instance
+        stop_event: Event to signal when to stop polling
+    """
+    while not stop_event.is_set():
+        try:
+            position = await machine.get_position()
+            timestamp = datetime.utcnow().isoformat() + "Z"
+            result = {
+                "timestamp": timestamp,
+                "qubot": position.get("qubot", {}),
+                "pipette": position.get("pipette", ""),
+            }
+            print(json.dumps(result))
+        except (ValueError, IOError, RuntimeError) as e:
+            timestamp = datetime.utcnow().isoformat() + "Z"
+            result = {
+                "timestamp": timestamp,
+                "qubot": {},
+                "pipette": "",
+                "error": str(e),
+            }
+            print(json.dumps(result))
+        
+        # Wait 1 second, but check stop_event periodically
+        try:
+            await asyncio.wait_for(stop_event.wait(), timeout=1.0)
+            break
+        except asyncio.TimeoutError:
+            continue
+
+
+def run_operations(machine: First):
+    """
+    Run the machine operations synchronously.
+    
+    Args:
+        machine: First machine instance
+    """
+    machine.start_video_recording()
+    machine.attach_tip(slot="A3", well="G8")
+    machine.aspirate_from(slot="C2", well="A1", amount=100, height_from_bottom=10)
+    machine.dispense_to(slot="C2", well="B4", amount=100, height_from_bottom=50)
+    machine.drop_tip(slot="C1", well="A1", height_from_bottom=10)
+    machine.stop_video_recording()
+
+
+async def main():
+    """Main async function to run operations and position polling concurrently."""
+    # Connect machine
+    machine = First(
+        qubot_port="/dev/ttyACM0",
+        sartorius_port="/dev/ttyUSB0",
+        camera_index=0,
+    )
+    
+    # View available labware
+    print(get_available_labware())
+
+    # Define deck layout declaratively and load all at once
+    machine.load_deck(
+        {
+            "C1": "trash_bin",
+            "C2": "polyelectric_8_wellplate_30000ul",
+            "A3": "opentrons_96_tiprack_300ul",
+        }
+    )
+
+    print(machine.deck)
+    print(machine.deck["C2"])
+
+    machine.startup()  # Connects all controllers, homes gantry, and initializes pipette
+    
+    # Create event to signal when operations are done
+    stop_event = asyncio.Event()
+    
+    # Start position polling task
+    polling_task = asyncio.create_task(poll_position(machine, stop_event))
+    
+    # Run operations in a thread pool (since they're blocking)
+    try:
+        await asyncio.to_thread(run_operations, machine)
+    finally:
+        # Signal polling to stop
+        stop_event.set()
+        # Wait for polling task to finish
+        await polling_task
+    
+    # Shutdown machine
+    machine.shutdown()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

{puda_drivers-0.0.14 → puda_drivers-0.0.16}/uv.lock

@@ -89,7 +89,7 @@ wheels = [
 
 [[package]]
 name = "puda-drivers"
-version = "0.0.14"
+version = "0.0.16"
 source = { editable = "." }
 dependencies = [
     { name = "nats-py" },