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

{puda_drivers-0.0.5 → puda_drivers-0.0.7}/.gitignore

@@ -129,3 +129,7 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# Log files
+logs/
+*.log

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: puda-drivers
-Version: 0.0.5
+Version: 0.0.7
 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
@@ -27,6 +27,7 @@ Hardware drivers for the PUDA (Physical Unified Device Architecture) platform. T
 - **Gantry Control**: Control G-code compatible motion systems (e.g., QuBot)
 - **Liquid Handling**: Interface with Sartorius rLINE® pipettes and dispensers
 - **Serial Communication**: Robust serial port management with automatic reconnection
+- **Logging**: Configurable logging with optional file output to logs folder
 - **Cross-platform**: Works on Linux, macOS, and Windows
 
 ## Installation
@@ -47,6 +48,37 @@ pip install -e .
 
 ## Quick Start
 
+### Logging Configuration
+
+Configure logging for your application with optional file output:
+
+```python
+import logging
+from puda_drivers.core.logging import setup_logging
+
+# Configure logging with file output enabled
+setup_logging(
+    enable_file_logging=True,
+    log_level=logging.DEBUG,
+    logs_folder="logs", # Optional: default to logs
+    log_file_name="my_experiment"  # Optional: custom log file name
+)
+
+# Or disable file logging (console only)
+setup_logging(
+    enable_file_logging=False,
+    log_level=logging.INFO
+)
+```
+
+**Logging Options:**
+- `enable_file_logging`: If `True`, logs are written to files in the `logs/` folder. If `False`, logs only go to console (default: `False`)
+- `log_level`: Logging level constant (e.g., `logging.DEBUG`, `logging.INFO`, `logging.WARNING`, `logging.ERROR`, `logging.CRITICAL`) (default: `logging.DEBUG`)
+- `logs_folder`: Name of the folder to store log files (default: `"logs"`)
+- `log_file_name`: Custom name for the log file. If `None` or empty, uses timestamp-based name (e.g., `log_20250101_120000.log`). If provided without `.log` extension, it will be added automatically.
+
+When file logging is enabled, logs are saved to timestamped files (unless a custom name is provided) in the `logs/` folder. The logs folder is created automatically if it doesn't exist.
+
 ### Gantry Control (GCode)
 
 ```python
@@ -183,6 +215,29 @@ except ValueError as e:
 
 Validation errors are automatically logged at the ERROR level before the exception is raised.
 
+### Logging Best Practices
+
+For production applications, configure logging at the start of your script:
+
+```python
+import logging
+from puda_drivers.core.logging import setup_logging
+from puda_drivers.move import GCodeController
+
+# Configure logging first, before initializing devices
+setup_logging(
+    enable_file_logging=True,
+    log_level=logging.INFO,
+    log_file_name="gantry_operation"
+)
+
+# Now all device operations will be logged
+gantry = GCodeController(port_name="/dev/ttyACM0")
+# ... rest of your code
+```
+
+This ensures all device communication, movements, and errors are captured in log files for debugging and audit purposes.
+
 ## Finding Serial Ports
 
 To discover available serial ports on your system:

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

@@ -7,6 +7,7 @@ Hardware drivers for the PUDA (Physical Unified Device Architecture) platform. T
 - **Gantry Control**: Control G-code compatible motion systems (e.g., QuBot)
 - **Liquid Handling**: Interface with Sartorius rLINE® pipettes and dispensers
 - **Serial Communication**: Robust serial port management with automatic reconnection
+- **Logging**: Configurable logging with optional file output to logs folder
 - **Cross-platform**: Works on Linux, macOS, and Windows
 
 ## Installation
@@ -27,6 +28,37 @@ pip install -e .
 
 ## Quick Start
 
+### Logging Configuration
+
+Configure logging for your application with optional file output:
+
+```python
+import logging
+from puda_drivers.core.logging import setup_logging
+
+# Configure logging with file output enabled
+setup_logging(
+    enable_file_logging=True,
+    log_level=logging.DEBUG,
+    logs_folder="logs", # Optional: default to logs
+    log_file_name="my_experiment"  # Optional: custom log file name
+)
+
+# Or disable file logging (console only)
+setup_logging(
+    enable_file_logging=False,
+    log_level=logging.INFO
+)
+```
+
+**Logging Options:**
+- `enable_file_logging`: If `True`, logs are written to files in the `logs/` folder. If `False`, logs only go to console (default: `False`)
+- `log_level`: Logging level constant (e.g., `logging.DEBUG`, `logging.INFO`, `logging.WARNING`, `logging.ERROR`, `logging.CRITICAL`) (default: `logging.DEBUG`)
+- `logs_folder`: Name of the folder to store log files (default: `"logs"`)
+- `log_file_name`: Custom name for the log file. If `None` or empty, uses timestamp-based name (e.g., `log_20250101_120000.log`). If provided without `.log` extension, it will be added automatically.
+
+When file logging is enabled, logs are saved to timestamped files (unless a custom name is provided) in the `logs/` folder. The logs folder is created automatically if it doesn't exist.
+
 ### Gantry Control (GCode)
 
 ```python
@@ -163,6 +195,29 @@ except ValueError as e:
 
 Validation errors are automatically logged at the ERROR level before the exception is raised.
 
+### Logging Best Practices
+
+For production applications, configure logging at the start of your script:
+
+```python
+import logging
+from puda_drivers.core.logging import setup_logging
+from puda_drivers.move import GCodeController
+
+# Configure logging first, before initializing devices
+setup_logging(
+    enable_file_logging=True,
+    log_level=logging.INFO,
+    log_file_name="gantry_operation"
+)
+
+# Now all device operations will be logged
+gantry = GCodeController(port_name="/dev/ttyACM0")
+# ... rest of your code
+```
+
+This ensures all device communication, movements, and errors are captured in log files for debugging and audit purposes.
+
 ## Finding Serial Ports
 
 To discover available serial ports on your system:

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

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

puda_drivers-0.0.7/src/puda_drivers/core/__init__.py

@@ -0,0 +1,4 @@
+from .serialcontroller import SerialController, list_serial_ports
+from .logging import setup_logging
+
+__all__ = ["SerialController", "list_serial_ports", "setup_logging"]

puda_drivers-0.0.7/src/puda_drivers/core/logging.py

@@ -0,0 +1,73 @@
+"""
+Logging configuration utility.
+
+This module provides a function to configure logging with optional file output
+to a logs folder.
+"""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+
+def setup_logging(
+    enable_file_logging: bool = False,
+    log_level: int = logging.DEBUG,
+    logs_folder: str = "logs",
+    log_file_name: Optional[str] = None,
+) -> None:
+    """
+    Configure logging with optional file output to a logs folder.
+
+    Args:
+        enable_file_logging: If True, logs will be written to files in the logs folder.
+                           If False, logs will only be output to console.
+        log_level: Logging level constant from logging module (e.g., logging.DEBUG,
+                   logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL).
+                   Defaults to logging.DEBUG.
+        logs_folder: Name of the folder to store log files (default: "logs")
+        log_file_name: Custom name for the log file. If None or empty string, uses
+                      timestamp-based name. If provided without .log extension, it will
+                      be added automatically.
+    """
+    # Create logs folder if file logging is enabled
+    if enable_file_logging:
+        log_dir = Path(logs_folder)
+        log_dir.mkdir(exist_ok=True)
+        
+        # Create a log file with custom name or timestamp
+        if log_file_name and log_file_name.strip():  # None or empty/whitespace strings use timestamp
+            # Ensure .log extension if not present
+            if not log_file_name.endswith(".log"):
+                log_file_name = f"{log_file_name}.log"
+            log_file = log_dir / log_file_name
+        else:
+            # Default: timestamp-based name
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            log_file = log_dir / f"log_{timestamp}.log"
+        
+        # Configure logging with both console and file handlers
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[
+                logging.StreamHandler(),  # Console output
+                logging.FileHandler(log_file, mode="w"),  # File output
+            ],
+        )
+        
+        # Log that file logging is enabled
+        logger = logging.getLogger(__name__)
+        logger.info("File logging enabled. Log file: %s", log_file)
+    else:
+        # Configure logging with only console handler
+        logging.basicConfig(
+            level=log_level,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[logging.StreamHandler()],  # Console output only
+        )
+        
+        # Log that file logging is disabled
+        logger = logging.getLogger(__name__)
+        logger.info("File logging disabled. Logs will only be output to console.")

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

@@ -5,7 +5,7 @@ Generic Serial Controller for communicating with devices over serial ports.
 import time
 import logging
 from typing import Optional, List, Tuple
-from abc import ABC
+from abc import ABC, abstractmethod
 import serial
 import serial.tools.list_ports
 
@@ -159,9 +159,13 @@ class SerialController(ABC):
                 # Read all available bytes
                 response += self._serial.read(self._serial.in_waiting)
 
-                # Check for expected response markers for early return
+                # Check for expected response markers for early return for qubot
                 if b"ok" in response or b"err" in response:
                     break
+                
+                # Check for expected response markers for early return for sartorius
+                if b"\xba\r" in response:
+                    break
             else:
                 time.sleep(0.1)
 
@@ -175,18 +179,27 @@ class SerialController(ABC):
         # Decode once and check the decoded string
         decoded_response = response.decode("utf-8", errors="ignore").strip()
         
-        if "ok" in decoded_response.lower():
+        if "ok" in decoded_response.lower(): # for qubot
             self._logger.debug("<- Received response: %r", decoded_response)
-        elif "err" in decoded_response.lower():
+        elif "err" in decoded_response.lower(): # for qubot
             self._logger.error("<- Received error: %r", decoded_response)
+        elif "º" in decoded_response: # for sartorius
+            self._logger.debug("<- Received response: %r", decoded_response)
         else:
             self._logger.warning(
                 "<- Received unexpected response (no 'ok' or 'err'): %r", decoded_response
             )
         
         return decoded_response
+    
+    @abstractmethod
+    def _build_command(self, command: str, value: Optional[str] = None) -> str:
+        """
+        Build a command string according to the device protocol.
+        """
+        pass
 
-    def execute(self, command: str) -> str:
+    def execute(self, command: str, value: Optional[str] = None) -> str:
         """
         Send a command and read the response atomically.
         
@@ -205,5 +218,5 @@ 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(command)
+        self._send_command(self._build_command(command, value))
         return self._read_response()

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

@@ -143,7 +143,7 @@ class GCodeController(SerialController):
             self._feed = new_feed
             self._logger.debug("Feed rate set to: %s mm/min.", self._feed)
 
-    def _build_command(self, command: str) -> str:
+    def _build_command(self, command: str, value: Optional[str] = None) -> str:
         """
         Build a G-code command with terminator.
 
@@ -155,14 +155,14 @@ class GCodeController(SerialController):
         """
         return f"{command}{self.PROTOCOL_TERMINATOR}"
 
-    def wait_for_move(self) -> None:
+    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"))
+        self.execute("M400")
 
     def _validate_axis(self, axis: str) -> str:
         """
@@ -305,8 +305,8 @@ class GCodeController(SerialController):
             home_target = "All"
 
         self._logger.info("[%s] homing axis/axes: %s **", cmd, home_target)
-        self.execute(self._build_command(cmd))
-        self._logger.info("Homing of %s completed.", home_target)
+        self.execute(cmd)
+        self._logger.info("Homing of %s completed.\n", home_target)
 
         # Update internal position (optimistic zeroing)
         if axis:
@@ -447,17 +447,17 @@ class GCodeController(SerialController):
             raise ValueError("Move command issued with both Z and A movement. This is not supported.")
 
         # Step 0: Ensure absolute mode is active
-        self.execute(self._build_command("G90"))
+        self.execute("G90")
         needs_xy_move = needs_x_move or needs_y_move
 
         # Step 1: Move Z and A to SAFE_MOVE_HEIGHT if XY movement is needed
         if needs_xy_move:
-            self._logger.info(
+            self._logger.debug(
                 "Safe move: Raising Z and A to safe height (%s) before XY movement", self.SAFE_MOVE_HEIGHT
             )
             move_cmd = f"G1 Z-5 A-5 F{self._z_feed}"
-            self.execute(self._build_command(move_cmd))
-            self.wait_for_move()
+            self.execute(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)
@@ -471,9 +471,9 @@ class GCodeController(SerialController):
                 move_cmd += f" Y{position['Y']}"
             move_cmd += f" F{feed}"
 
-            self._logger.info("Executing XY move command: %s", move_cmd)
-            self.execute(self._build_command(move_cmd))
-            self.wait_for_move()
+            self._logger.debug("Executing XY move command: %s", move_cmd)
+            self.execute(move_cmd)
+            self._wait_for_move()
 
             # Update position for moved axes
             if needs_x_move:
@@ -484,21 +484,20 @@ class GCodeController(SerialController):
         # 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.execute(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.execute(move_cmd)
             self._current_position["A"] = position['A']
-        self.wait_for_move()
-
-        self._logger.info(
-            "Move complete. Final position: %s", self._current_position
-        )
+        self._wait_for_move()
         self._logger.debug("New internal position: %s", self._current_position)
 
         # Step 4: Post-move position synchronization check
-        self.sync_position()
+        self._sync_position()
+        self._logger.info(
+            "Move complete. Final position: %s\n", self._current_position
+        )
         
         return self._current_position
 
@@ -513,7 +512,7 @@ class GCodeController(SerialController):
             Returns an empty dictionary if the query fails or no positions are found.
         """
         self._logger.info("Querying current machine position (M114).")
-        res: str = self.execute(self._build_command("M114"))
+        res: str = self.execute("M114")
 
         # Extract position values using regex
         pattern = re.compile(r"([XYZA]):(-?\d+\.\d+)")
@@ -532,9 +531,10 @@ class GCodeController(SerialController):
                 )
                 continue
 
+        self._logger.info("Query position complete. Retrieved positions: %s", position_data)
         return position_data
 
-    def sync_position(self) -> Tuple[bool, Dict[str, float]]:
+    def _sync_position(self) -> Tuple[bool, Dict[str, float]]:
         """
         Synchronize internal position with actual machine position.
 
@@ -592,7 +592,7 @@ class GCodeController(SerialController):
                 self._logger.info("Synchronization move successfully completed.")
 
                 # Recursive call to verify position after move
-                return self.sync_position()
+                return self._sync_position()
             except (ValueError, RuntimeError, OSError) as e:
                 self._logger.error("Synchronization move failed: %s", e)
                 adjustment_needed = False
@@ -614,7 +614,7 @@ class GCodeController(SerialController):
             Machine information string from the device
         """
         self._logger.info("Querying machine information (M115).")
-        return self.execute(self._build_command("M115"))
+        return self.execute("M115")
 
     def get_internal_position(self) -> Dict[str, float]:
         """

{puda_drivers-0.0.5 → puda_drivers-0.0.7}/src/puda_drivers/transfer/liquid/sartorius/sartorius.py

@@ -72,7 +72,7 @@ class SartoriusController(SerialController):
             timeout,
         )
 
-    def _build_command(self, command_code: str, value: str = "") -> str:
+    def _build_command(self, command: str, value: Optional[str] = None) -> str:
         """
         Build a command string according to the Sartorius protocol.
 
@@ -88,28 +88,11 @@ class SartoriusController(SerialController):
         return (
             self.PROTOCOL_SOH
             + self.SLAVE_ADDRESS
-            + "R"
-            + command_code
-            + value
+            + command
+            + (f"{value}" if value else "")
             + self.PROTOCOL_TERMINATOR
         )
 
-    def _check_response_error(self, response: str, operation: str) -> None:
-        """
-        Check if a response contains an error and raise an exception if so.
-
-        Args:
-            response: Response string from the device
-            operation: Description of the operation being performed (for error message)
-
-        Raises:
-            SartoriusDeviceError: If the response contains an error
-        """
-        if self.ERROR_RESPONSE in response.lower():
-            raise SartoriusDeviceError(
-                f"{operation} failed. Device returned error: {response}"
-            )
-
     def _validate_speed(self, speed: int, direction: str = "speed") -> None:
         """
         Validate that a speed value is within the allowed range.
@@ -149,29 +132,6 @@ class SartoriusController(SerialController):
             )
         return value_str
 
-    def _execute_command(
-        self, command_code: str, value: str = "", operation: str = ""
-    ) -> str:
-        """
-        Execute a command and return the response.
-
-        Args:
-            command_code: Command code to execute
-            value: Optional value for the command
-            operation: Description of the operation (for logging and error messages)
-
-        Returns:
-            Response string from the device
-
-        Raises:
-            SartoriusDeviceError: If the device returns an error
-        """
-        command = self._build_command(command_code, value)
-        self._send_command(command)
-        response = self._read_response()
-        self._check_response_error(response, operation or f"Command {command_code}")
-        return response
-
     def initialize(self) -> None:
         """
         Initialize the pipette unit (RZ command).
@@ -183,8 +143,8 @@ class SartoriusController(SerialController):
             SartoriusDeviceError: If initialization fails
         """
         self._logger.info("** Initializing Pipette Head (RZ) **")
-        self._execute_command("Z", operation="Pipette initialization")
-        self._logger.info("** Pipette Initialization Complete **")
+        self.execute(command="RZ")
+        self._logger.info("** Pipette Initialization Complete **\n")
 
     def get_inward_speed(self) -> int:
         """
@@ -197,7 +157,7 @@ class SartoriusController(SerialController):
             SartoriusDeviceError: If the query fails
         """
         self._logger.info("** Querying Inward Speed (DI) **")
-        response = self._execute_command("DI", operation="Inward speed query")
+        response = self.execute(command="DI")
 
         if len(response) < 2:
             raise SartoriusDeviceError(
@@ -205,7 +165,7 @@ class SartoriusController(SerialController):
             )
 
         speed = int(response[1])
-        self._logger.info("** Current Inward Speed: %s **", speed)
+        self._logger.info("** Current Inward Speed: %s **\n", speed)
         return speed
 
     def set_inward_speed(self, speed: int) -> None:
@@ -221,8 +181,8 @@ class SartoriusController(SerialController):
         """
         self._validate_speed(speed, "Inward")
         self._logger.info("** Setting Inward Speed (SI, Speed: %s) **", speed)
-        self._execute_command("I", value=str(speed), operation="Setting inward speed")
-        self._logger.info("** Inward Speed Set to %s Successfully **", speed)
+        self.execute(command="SI", value=str(speed))
+        self._logger.info("** Inward Speed Set to %s Successfully **\n", speed)
 
     def get_outward_speed(self) -> int:
         """
@@ -235,7 +195,7 @@ class SartoriusController(SerialController):
             SartoriusDeviceError: If the query fails
         """
         self._logger.info("** Querying Outward Speed (DO) **")
-        response = self._execute_command("DO", operation="Outward speed query")
+        response = self.execute(command="DO")
 
         if len(response) < 2:
             raise SartoriusDeviceError(
@@ -243,7 +203,7 @@ class SartoriusController(SerialController):
             )
 
         speed = int(response[1])
-        self._logger.info("** Current Outward Speed: %s **", speed)
+        self._logger.info("** Current Outward Speed: %s **\n", speed)
         return speed
 
     def set_outward_speed(self, speed: int) -> None:
@@ -259,8 +219,8 @@ class SartoriusController(SerialController):
         """
         self._validate_speed(speed, "Outward")
         self._logger.info("** Setting Outward Speed (SO, Speed: %s) **", speed)
-        self._execute_command("O", value=str(speed), operation="Setting outward speed")
-        self._logger.info("** Outward Speed Set to %s Successfully **", speed)
+        self.execute(command="SO", value=str(speed))
+        self._logger.info("** Outward Speed Set to %s Successfully **\n", speed)
 
     def run_to_position(self, position: int) -> None:
         """
@@ -275,9 +235,10 @@ class SartoriusController(SerialController):
         """
         position_str = self._validate_no_leading_zeros(position, "RP")
         self._logger.info("** Run to absolute Position (RP, Position: %s) **", position)
-        self._execute_command("P", value=position_str, operation="Run to position")
-        self._logger.info("** Reached Position %s Successfully **", position)
-
+        self.execute(command="RP", value=position_str)
+        self._logger.info("** Reached Position %s Successfully **\n", position)
+        
+    # instead of run_inward, use aspirate
     def aspirate(self, amount: float) -> None:
         """
         Aspirate fluid from the current location.
@@ -294,9 +255,10 @@ class SartoriusController(SerialController):
 
         steps = int(amount / self.MICROLITER_PER_STEP)
         self._logger.info("** Aspirating %s uL (RI%s steps) **", amount, steps)
-        self._execute_command("I", value=str(steps), operation="Aspirate")
-        self._logger.info("** Aspirated %s uL Successfully **", amount)
+        self.execute(command="RI", value=str(steps))
+        self._logger.info("** Aspirated %s uL Successfully **\n", amount)
 
+    # instead of run_outward, use dispense
     def dispense(self, amount: float) -> None:
         """
         Dispense fluid at the current location.
@@ -313,8 +275,8 @@ class SartoriusController(SerialController):
 
         steps = int(amount / self.MICROLITER_PER_STEP)
         self._logger.info("** Dispensing %s uL (RO%s steps) **", amount, steps)
-        self._execute_command("O", value=str(steps), operation="Dispense")
-        self._logger.info("** Dispensed %s uL Successfully **", amount)
+        self.execute(command="RO", value=str(steps))
+        self._logger.info("** Dispensed %s uL Successfully **\n", amount)
 
     def eject_tip(self, return_position: int = 30) -> None:
         """
@@ -333,10 +295,8 @@ class SartoriusController(SerialController):
             return_position,
             return_position,
         )
-        self._execute_command(
-            "E", value=position_str, operation="Eject tip with return position"
-        )
-        self._logger.info("** Tip Ejection Complete **")
+        self.execute(command="RE", value=position_str)
+        self._logger.info("** Tip Ejection Complete **\n")
 
     def run_blowout(self, return_position: Optional[int] = None) -> None:
         """
@@ -359,14 +319,12 @@ class SartoriusController(SerialController):
                 return_position,
                 return_position,
             )
-            self._execute_command(
-                "B", value=position_str, operation="Blowout with return position"
-            )
+            self.execute(command="RB", value=position_str)
         else:
             self._logger.info("** Running Blowout (RB) **")
-            self._execute_command("B", operation="Blowout")
+            self.execute(command="RB")
 
-        self._logger.info("** Blowout Complete **")
+        self._logger.info("** Blowout Complete **\n")
 
     def get_status(self) -> str:
         """
@@ -379,7 +337,7 @@ class SartoriusController(SerialController):
             SartoriusDeviceError: If the status query fails
         """
         self._logger.info("** Querying Pipette Status (DS) **")
-        response = self._execute_command("DS", operation="Status query")
+        response = self.execute(command="DS")
 
         if len(response) < 2:
             raise SartoriusDeviceError(
@@ -389,10 +347,37 @@ class SartoriusController(SerialController):
         status_code = response[1]
         if status_code in STATUS_CODES:
             status_message = STATUS_CODES[status_code]
-            self._logger.info("Pipette Status Code [%s]: %s", status_code, status_message)
+            self._logger.info("Pipette Status Code [%s]: %s\n", status_code, status_message)
         else:
             self._logger.warning(
-                "Pipette Status Code [%s]: Unknown Status Code", status_code
+                "Pipette Status Code [%s]: Unknown Status Code\n", status_code
             )
 
         return status_code
+    
+    def get_position(self) -> int:
+        """
+        Query the current position of the pipette (DP command).
+
+        Returns:
+            Current position in steps
+        """
+        self._logger.info("** Querying Position (DP) **")
+        response = self.execute(command="DP")
+        self._logger.info("** Position: %s steps **\n", response)
+        return response
+    
+    def get_liquid_level(self) -> int:
+        """
+        Query the current liquid level of the pipette (DN command).
+
+        Returns:
+            Current liquid level in microliters (µL)
+        """
+        # without tip 240 - 300
+        # incrase with tip attached and liquid
+        # 160 - 400
+        self._logger.info("** Querying Liquid Level (DN) **")
+        response = self.execute(command="DN")
+        self._logger.info("** Liquid Level: %s uL **\n", response)
+        return response

{puda_drivers-0.0.5 → puda_drivers-0.0.7}/tests/pipette.py

@@ -1,22 +1,21 @@
 import logging
 from puda_drivers.transfer.liquid.sartorius import SartoriusController
+from puda_drivers.core.logging import setup_logging
 
 # Optional: 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",
+# --- LOGGING CONFIGURATION ---
+# All loggers in imported modules (SerialController, SartoriusController) will inherit this setup.
+setup_logging(
+    enable_file_logging=False,
+    log_level=logging.DEBUG,  # Use logging.DEBUG to see all (DEBUG, INFO, WARNING, ERROR, CRITICAL) logs
 )
 
-# 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)
+# OPTIONAL: If you only want specific loggers at specific level, you can specifically set it here
+# logging.getLogger('puda_drivers.transfer.liquid.sartorius').setLevel(logging.INFO)
 
 
 # --- CONFIGURATION ---
@@ -36,25 +35,34 @@ def test_pipette_operations():
 
     try:
         # 1. Initialize and Connect
-        print("\n[STEP 1] Connecting to pipette...")
+        print("[STEP 1] Connecting to pipette...")
         # SartoriusController connects automatically in __init__, no need to call connect()
-        
+
         # Always start with initializing
         pipette.initialize()
 
+        pipette.get_status()
+        pipette.get_liquid_level()
+
+        # 2. Set and get inward and outward speeds
+        print("[STEP 2] Setting and getting inward and outward speeds...")
+        pipette.set_inward_speed(3)
         pipette.get_inward_speed()
-        # print("\n set inward speed to 3")
-        # pipette.set_inward_speed(3)
+
+        pipette.set_outward_speed(3)
+        pipette.get_outward_speed()
+        pipette.run_to_position(100)
+        pipette.get_position()
 
         # 3. Eject Tip (if any)
-        # print("\n[STEP 3] Ejecting Tip (if any)...")
-        # pipette.eject_tip(return_position=30)
-        # print(f"\n[STEP 3] Aspirate {TRANSFER_VOLUME} uL...")
-        # pipette.aspirate(amount=TRANSFER_VOLUME)
+        print("[STEP 3] Ejecting Tip (if any)...")
+        pipette.eject_tip(return_position=30)
+        print(f"[STEP 3] Aspirate {TRANSFER_VOLUME} uL...")
+        pipette.aspirate(amount=TRANSFER_VOLUME)
 
         # 4. Dispense
-        # print(f"\n[STEP 4] Dispensing {TRANSFER_VOLUME} uL...")
-        # pipette.dispense(amount=TRANSFER_VOLUME)
+        print(f"[STEP 4] Dispensing {TRANSFER_VOLUME} uL...")
+        pipette.dispense(amount=TRANSFER_VOLUME)
 
         # # 5. Eject Tip
         # print("\n[STEP 5] Ejecting Tip...")

{puda_drivers-0.0.5 → puda_drivers-0.0.7}/tests/qubot.py

@@ -1,21 +1,20 @@
 import logging
 from puda_drivers.move import GCodeController
+from puda_drivers.core.logging import setup_logging
 
 # Optinal: finding ports
-import serial.tools.list_ports
-for port, desc, hwid in serial.tools.list_ports.comports():
-    print(f"{port}: {desc} [{hwid}]")
+# 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
+# --- LOGGING CONFIGURATION ---
 # 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",
+setup_logging(
+    enable_file_logging=True,
+    log_level=logging.INFO,  # Use logging.DEBUG to see all (DEBUG, INFO, WARNING, ERROR, CRITICAL) logs
 )
 
-# 2. OPTIONAL: If you only want GCodeController's logs at specific level, you can specifically set it here
+# 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"
@@ -46,7 +45,6 @@ def main():
 
         # qubot.query_position()
         # Always start with homing
-        print("\n")
         qubot.home()
 
         # # Setting feed rate (aka move speed) 
@@ -54,26 +52,22 @@ def main():
         # 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")
+        # for anything in the -axis, will have to be moved individually, else error will be raised
         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}")
+        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()
+        # sync position is always called after move automatically (now private: _sync_position())
+        # Position synchronization happens automatically after each move
 
-        # print("\n")
         # qubot.move_absolute(x=330.0, y=-440.0, z=-175.0)
-
-        # print("\n")
-        # qubot.sync_position()
+        # Position synchronization happens automatically after each move
         # Example of an ERROR - invalid axis
         # try:
         #     qubot.home(axis="B")  # Generates ERROR
@@ -100,6 +94,9 @@ def main():
         #     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}")
+        
+        qubot.disconnect()
+        print("Disconnected from qubot")
 
     except Exception as e:
         logging.getLogger(__name__).error("An unrecoverable error occurred: %s", e)

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

@@ -2,11 +2,12 @@ import logging
 import serial
 from puda_drivers.move import GCodeController
 from puda_drivers.transfer.liquid.sartorius import SartoriusController
+from puda_drivers.core.logging import setup_logging
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,  # Use INFO level for cleaner output during automation
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+# --- LOGGING CONFIGURATION ---
+setup_logging(
+    enable_file_logging=False,
+    log_level=logging.INFO,  # Use INFO level for cleaner output during automation
 )
 
 # Qubot Configuration
@@ -65,6 +66,7 @@ try:
     print("Connecting to pipette")
     # SartoriusController connects automatically in __init__, no need to call connect()
     pipette = SartoriusController(port_name=SARTORIUS_PORT)
+    # always start with initializing
     pipette.initialize()
 except Exception as e:
     print(f"FATAL ERROR: Could not initialize/connect Sartorius: {e}")
@@ -90,10 +92,6 @@ def run_automation():
         # 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
-        pos = qubot.move_absolute(z=SAFE_Z_POS)
-        print(f"  Position after safe Z move: {pos}")
-
         # Move to the source well (ASPIRATE_POS)
         pos = qubot.move_absolute(
             x=ASPIRATE_POS["X"], y=ASPIRATE_POS["Y"], z=ASPIRATE_POS["Z"], feed=3000
@@ -129,10 +127,6 @@ def run_automation():
         # 6. Protocol Step 4: Finalization
         print("\nProtocol Step 4: Finalizing")
 
-        # Move back to safe Z-height
-        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
         pos = qubot.move_absolute(x=10.0, y=-10.0)
         print(f"  Position at trash bin: {pos}")

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

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

puda_drivers-0.0.5/src/puda_drivers/core/__init__.py

@@ -1,3 +0,0 @@
-from .serialcontroller import SerialController, list_serial_ports
-
-__all__ = ["SerialController", "list_serial_ports"]