puda-drivers 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

puda_drivers/move/gcode.py

@@ -1,22 +1,64 @@
 """
-A standalone Python class for controlling G-code devices
-via serial communication.
+G-code controller for motion systems.
 
-Provides methods for connection management, basic movement commands, and port discovery.
+This module provides a Python interface for controlling G-code compatible motion
+systems (e.g., QuBot) via serial communication. All movements are executed in
+absolute coordinates, with relative moves converted to absolute internally.
+Supports homing and position synchronization.
 """
 
 import re
-from typing import Optional, Dict, Tuple
 import logging
+from dataclasses import dataclass
+from typing import Optional, Dict, Tuple, Union
+
 from puda_drivers.core.serialcontroller import SerialController
 
 
+@dataclass
+class AxisLimits:
+    """Holds min/max limits for an axis."""
+
+    min: float
+    max: float
+
+    def validate(self, value: float) -> None:
+        """
+        Validate that a value is within the axis limits.
+
+        Args:
+            value: Value to validate
+
+        Raises:
+            ValueError: If value is outside the limits
+        """
+        if not (self.min <= value <= self.max):
+            raise ValueError(
+                f"Value {value} outside axis limits [{self.min}, {self.max}]"
+            )
+
+
 class GCodeController(SerialController):
+    """
+    Controller for G-code compatible motion systems.
+
+    This class provides methods for controlling multi-axis motion systems that
+    understand G-code commands. All movements are executed in absolute coordinates,
+    with relative moves converted to absolute internally. Supports homing and
+    position synchronization.
+
+    Attributes:
+        DEFAULT_FEEDRATE: Default feed rate in mm/min (3000)
+        MAX_FEEDRATE: Maximum allowed feed rate in mm/min (3000)
+        TOLERANCE: Position synchronization tolerance in mm (0.01)
+    """
+
     DEFAULT_FEEDRATE = 3000  # mm/min
     MAX_FEEDRATE = 3000  # mm/min
     TOLERANCE = 0.01  # tolerance for position sync in mm
 
     PROTOCOL_TERMINATOR = "\r"
+    VALID_AXES = "XYZA"
 
     def __init__(
         self,
@@ -26,19 +68,22 @@ class GCodeController(SerialController):
         feed: int = DEFAULT_FEEDRATE,
     ):
         """
-        Initializes the GCodeController.
+        Initialize the G-code controller.
 
         Args:
-            port (Optional[str]): The serial port (e.g., 'COM5'). Defaults to None.
-            baudrate (int): The baud rate for serial communication. Defaults to 9600.
-            timeout (int): The read/write timeout in seconds. Defaults to 5.
+            port_name: Serial port name (e.g., '/dev/ttyACM0' or 'COM3')
+            baudrate: Baud rate for serial communication. Defaults to 9600.
+            timeout: Timeout in seconds for operations. Defaults to 20.
+            feed: Initial feed rate in mm/min. Defaults to 3000.
         """
         super().__init__(port_name, baudrate, timeout)
 
-        # Initialize instance-specific logger
         self._logger = logging.getLogger(__name__)
         self._logger.info(
-            f"GCodeController initialized with port='{port_name}', baudrate={baudrate}, timeout={timeout}"
+            "GCodeController initialized with port='%s', baudrate=%s, timeout=%s",
+            port_name,
+            baudrate,
+            timeout,
         )
 
         # Tracks internal position state
@@ -49,81 +94,208 @@ class GCodeController(SerialController):
             "A": 0.0,
         }
         self._feed: int = feed
-        self._is_absolute_mode: bool = True  # absolute mode by default
+
+        # Initialize axis limits with default values
+        self._axis_limits: Dict[str, AxisLimits] = {
+            "X": AxisLimits(0, 0),
+            "Y": AxisLimits(0, 0),
+            "Z": AxisLimits(0, 0),
+            "A": AxisLimits(0, 0),
+        }
 
     @property
-    def feed(self):
-        """The current feed rate."""
+    def feed(self) -> int:
+        """Get the current feed rate in mm/min."""
         return self._feed
 
     @feed.setter
-    def feed(self, new_feed: int):
-        """Set the movement feed rate, enforcing the maximum limit."""
+    def feed(self, new_feed: int) -> None:
+        """
+        Set the movement feed rate, enforcing the maximum limit.
+
+        Args:
+            new_feed: New feed rate in mm/min (must be > 0)
 
-        # 1. Ensure the value is positive
+        Raises:
+            ValueError: If feed rate is not positive
+        """
         if new_feed <= 0:
-            error_msg = f"Attempted to set invalid feed rate: {new_feed}. Must be > 0."
+            error_msg = (
+                f"Attempted to set invalid feed rate: {new_feed}. Must be > 0."
+            )
             self._logger.error(error_msg)
             raise ValueError(error_msg)
 
-        # 2. Check and enforce the maximum rate
         if new_feed > self.MAX_FEEDRATE:
-            # Log the change and cap the value
             self._logger.warning(
-                f"Requested feed rate ({new_feed}) exceeds maximum ({self.MAX_FEEDRATE}). "
-                f"Setting feed rate to maximum: {self.MAX_FEEDRATE}."
+                "Requested feed rate (%s) exceeds maximum (%s). "
+                "Setting feed rate to maximum: %s.",
+                new_feed,
+                self.MAX_FEEDRATE,
+                self.MAX_FEEDRATE,
             )
             self._feed = self.MAX_FEEDRATE
         else:
-            # Set the value normally
             self._feed = new_feed
-            self._logger.debug(f"Feed rate set to: {self._feed} mm/min.")
+            self._logger.debug("Feed rate set to: %s mm/min.", self._feed)
 
     def _build_command(self, command: str) -> str:
-        """Helper function to build a G-code command with terminator."""
+        """
+        Build a G-code command with terminator.
+
+        Args:
+            command: G-code command string (without terminator)
+
+        Returns:
+            Complete command string with terminator
+        """
         return f"{command}{self.PROTOCOL_TERMINATOR}"
 
-    def home(self, axis: Optional[str] = None) -> None:
+    def _validate_axis(self, axis: str) -> str:
         """
-        Homes one or all axes (G28 command).
+        Validate and normalize an axis name.
 
         Args:
-            axis (str, optional): The axis to home ('X', 'Y', 'Z', 'A', etc.).
-                                  If None, homes all axes (G28).
+            axis: Axis name to validate
+
+        Returns:
+            Uppercase axis name
 
         Raises:
-            ValueError: If an invalid axis character is provided.
+            ValueError: If axis is not valid
         """
-        valid_axes = "XYZA"
+        axis_upper = axis.upper()
+        if axis_upper not in self.VALID_AXES:
+            self._logger.error(
+                "Invalid axis '%s' provided. Must be one of: %s.",
+                axis_upper,
+                ", ".join(self.VALID_AXES),
+            )
+            raise ValueError(
+                f"Invalid axis. Must be one of: {', '.join(self.VALID_AXES)}."
+            )
+        return axis_upper
 
-        # 1. Axis Validation and Normalization, Command Construction
-        if axis:
-            axis = axis.upper()
-            if axis not in valid_axes:
-                self._logger.error(
-                    f"Invalid axis '{axis}' provided for homing. Must be one of: {', '.join(valid_axes)}."
-                )
-                raise ValueError(
-                    f"Invalid axis. Must be one of: {', '.join(valid_axes)}."
-                )
+    def _validate_move_positions(
+        self,
+        x: Optional[float] = None,
+        y: Optional[float] = None,
+        z: Optional[float] = None,
+        a: Optional[float] = None,
+    ) -> None:
+        """
+        Validate that move positions are within axis limits.
+
+        Only validates axes that are being moved (not None). Raises ValueError
+        if any position is outside the configured limits.
+
+        Args:
+            x: Target X position (optional)
+            y: Target Y position (optional)
+            z: Target Z position (optional)
+            a: Target A position (optional)
+
+        Raises:
+            ValueError: If any position is outside the axis limits
+        """
+        if x is not None:
+            if "X" in self._axis_limits:
+                try:
+                    self._axis_limits["X"].validate(x)
+                except ValueError as e:
+                    self._logger.error("Move validation failed for X axis: %s", e)
+                    raise
+        if y is not None:
+            if "Y" in self._axis_limits:
+                try:
+                    self._axis_limits["Y"].validate(y)
+                except ValueError as e:
+                    self._logger.error("Move validation failed for Y axis: %s", e)
+                    raise
+        if z is not None:
+            if "Z" in self._axis_limits:
+                try:
+                    self._axis_limits["Z"].validate(z)
+                except ValueError as e:
+                    self._logger.error("Move validation failed for Z axis: %s", e)
+                    raise
+        if a is not None:
+            if "A" in self._axis_limits:
+                try:
+                    self._axis_limits["A"].validate(a)
+                except ValueError as e:
+                    self._logger.error("Move validation failed for A axis: %s", e)
+                    raise
+
+    def set_axis_limits(
+        self, axis: str, min_val: float, max_val: float
+    ) -> None:
+        """
+        Set the min/max limits for an axis.
+
+        Args:
+            axis: Axis name ('X', 'Y', 'Z', 'A')
+            min_val: Minimum allowed value
+            max_val: Maximum allowed value
+
+        Raises:
+            ValueError: If axis is unknown or min >= max
+        """
+        axis = self._validate_axis(axis)
+
+        if min_val >= max_val:
+            raise ValueError("min must be < max")
+
+        self._axis_limits[axis] = AxisLimits(min_val, max_val)
+        self._logger.info(
+            "Set limits for axis %s: [%s, %s]", axis, min_val, max_val
+        )
+
+    def get_axis_limits(
+        self, axis: Optional[str] = None
+    ) -> Union[AxisLimits, Dict[str, AxisLimits]]:
+        """
+        Get the current limits for an axis or all axes.
+
+        Args:
+            axis: Optional axis name ('X', 'Y', 'Z', 'A'). If None, returns all limits.
+
+        Returns:
+            If axis is specified: AxisLimits object with min and max values.
+            If axis is None: Dictionary of all axis limits.
+
+        Raises:
+            ValueError: If axis is unknown (only when axis is provided)
+        """
+        if axis is None:
+            return self._axis_limits.copy()
+        axis = self._validate_axis(axis)
+        return self._axis_limits[axis]
+
+    def home(self, axis: Optional[str] = None) -> None:
+        """
+        Home one or all axes (G28 command).
+
+        Args:
+            axis: Optional axis to home ('X', 'Y', 'Z', 'A').
+                  If None, homes all axes.
 
+        Raises:
+            ValueError: If an invalid axis is provided
+        """
+        if axis:
+            axis = self._validate_axis(axis)
             cmd = f"G28 {axis}"
             home_target = axis
         else:
             cmd = "G28"
             home_target = "All"
 
-        # 2. Command Execution
-        self._logger.info(f"[{cmd}] homing axis/axes: {home_target} **")
-        # self._send_command(self._build_command(cmd))
-        self._send_command("G28\r")
-        self._logger.info(f"Homing of {home_target} completed.")
+        self._logger.info("[%s] homing axis/axes: %s **", cmd, home_target)
+        self._send_command(self._build_command(cmd))
+        self._logger.info("Homing of %s completed.", home_target)
 
-        # Verify position after homing
-        # self.sync_position()
-
-        # 3. Internal Position Update (Optimistic Zeroing)
-        # If the homing was for a specific axis, zero only that axis.
+        # Update internal position (optimistic zeroing)
         if axis:
             self.current_position[axis] = 0.0
         else:
@@ -131,7 +303,8 @@ class GCodeController(SerialController):
                 self.current_position[key] = 0.0
 
         self._logger.debug(
-            f"Internal position updated (optimistically zeroed) to {self.current_position}"
+            "Internal position updated (optimistically zeroed) to %s",
+            self.current_position,
         )
 
     def move_absolute(
@@ -143,18 +316,31 @@ class GCodeController(SerialController):
         feed: Optional[int] = None,
     ) -> None:
         """
-        Moves the device to an absolute position (G90 + G1 command).
+        Move to an absolute position (G90 + G1 command).
+
+        Args:
+            x: Target X position (optional)
+            y: Target Y position (optional)
+            z: Target Z position (optional)
+            a: Target A position (optional)
+            feed: Feed rate for this move (optional, uses current feed if not specified)
+
+        Raises:
+            ValueError: If any position is outside the axis limits
         """
+        # Validate positions before executing move
+        self._validate_move_positions(x=x, y=y, z=z, a=a)
+
+        feed_rate = feed if feed is not None else self._feed
         self._logger.info(
-            f"Preparing absolute move to X:{x}, Y:{y}, Z:{z}, A:{a} at F:{feed if feed is not None else self._feed}"
+            "Preparing absolute move to X:%s, Y:%s, Z:%s, A:%s at F:%s",
+            x,
+            y,
+            z,
+            a,
+            feed_rate,
         )
 
-        # Ensure absolute mode is active
-        if not self._is_absolute_mode:
-            self._logger.debug("Switching to absolute positioning mode (G90).")
-            self._send_command(self._build_command("G90"))
-            self._is_absolute_mode = True
-
         self._execute_move(x=x, y=y, z=z, a=a, feed=feed)
 
     def move_relative(
@@ -166,19 +352,38 @@ class GCodeController(SerialController):
         feed: Optional[int] = None,
     ) -> None:
         """
-        Moves the device relative to the current position (G91 + G1 command).
+        Move relative to the current position (converted to absolute move internally).
+
+        Args:
+            x: Relative X movement (optional)
+            y: Relative Y movement (optional)
+            z: Relative Z movement (optional)
+            a: Relative A movement (optional)
+            feed: Feed rate for this move (optional, uses current feed if not specified)
+
+        Raises:
+            ValueError: If any resulting absolute position is outside the axis limits
         """
+        feed_rate = feed if feed is not None else self._feed
         self._logger.info(
-            f"Preparing relative move by dX:{x}, dY:{y}, dZ:{z}, dA:{a} at F:{feed if feed is not None else self._feed}"
+            "Preparing relative move by dX:%s, dY:%s, dZ:%s, dA:%s at F:%s",
+            x,
+            y,
+            z,
+            a,
+            feed_rate,
         )
 
-        # Ensure relative mode is active
-        if self._is_absolute_mode:
-            self._logger.debug("Switching to relative positioning mode (G91).")
-            self._send_command(self._build_command("G91"))
-            self._is_absolute_mode = False
+        # 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
 
-        self._execute_move(x=x, y=y, z=z, a=a, feed=feed)
+        # 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)
 
     def _execute_move(
         self,
@@ -188,70 +393,130 @@ class GCodeController(SerialController):
         a: Optional[float] = None,
         feed: Optional[int] = None,
     ) -> None:
-        """Internal helper for executing G1 move commands."""
+        """
+        Internal helper for executing G1 move commands with safe movement pattern.
+        All coordinates are treated as absolute positions.
 
-        # 1. Map axis names to their input values
-        move_deltas = {"X": x, "Y": y, "Z": z, "A": a}
+        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)
 
-        move_cmd = "G1"
+        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()
-        movement_occurred = False
+        has_x = x is not None
+        has_y = y is not None
+        has_z = z is not None
+        has_a = a is not None
 
-        # 2. Build the G-code command and calculate target position
-        for axis, value in move_deltas.items():
-            if value is not None:
-                move_cmd += f" {axis}{value}"
-
-                # Calculate the target position
-                if self._is_absolute_mode:
-                    target_pos[axis] = value
-                else:
-                    target_pos[axis] = self.current_position[axis] + value
+        if not (has_x or has_y or has_z or has_a):
+            self._logger.warning(
+                "Move command issued without any axis movement. Skipping transmission."
+            )
+            return
 
-                movement_occurred = True
+        # 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
 
-        # 3. Add on Feed Rate to command
         feed_rate = feed if feed is not None else self._feed
-        # Final safety check on the rate used in the command
         if feed_rate > self.MAX_FEEDRATE:
             feed_rate = self.MAX_FEEDRATE
-        move_cmd += f" F{feed_rate}"
 
-        # 4. Check for movement and return if none
-        if not movement_occurred:
-            self._logger.warning(
-                "Move command issued without any axis movement. Skipping transmission."
-            )
-            return
+        # Ensure absolute mode is active
+        self._send_command(self._build_command("G90"))
 
-        # 5. Execute command and update position (Optimistic update)
-        self._logger.info(f"Executing move command: {move_cmd}")
-        self._send_command(self._build_command(move_cmd))
+        # 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 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)
+            self._logger.info(
+                "Safe move: Raising Z to safe height (0) before XY movement"
+            )
+            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 = "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}"
+
+            self._logger.info("Executing XY move command: %s", move_cmd)
+            self._send_command(self._build_command(move_cmd))
+
+            # 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
 
         self._logger.info(
-            f"Move complete. Updating internal position from {self.current_position} to {target_pos}"
+            "Move complete. Final position: %s", self.current_position
         )
+        self._logger.debug("New internal position: %s", self.current_position)
 
-        self.current_position = target_pos
-        self._logger.debug(f"New internal position: {self.current_position}")
-
-        # 6. Post-Move Position Synchronization Check
+        # Post-move position synchronization check
         self.sync_position()
 
     def query_position(self) -> Dict[str, float]:
         """
-        Queries the Qubot for its current machine position (M114 command).
+        Query the current machine position (M114 command).
 
         Returns:
-            Dict[str, float]: A dictionary containing the updated X, Y, Z, and A positions.
+            Dictionary containing X, Y, Z, and A positions
+
+        Note:
+            Returns an empty dictionary if the query fails or no positions are found.
         """
         self._logger.info("Querying current machine position (M114).")
-        self._send_command(self._build_command("M114"))
-        res: str = self._read_response()
+        res: str = self.execute(self._build_command("M114"))
 
         # Extract position values using regex
-        pattern = re.compile(r"([XYZAE]):(\-?\d+\.\d+)")
-        # Find all matches (e.g., [('X', '0.000'), ('Y', '0.000'), ...])
+        pattern = re.compile(r"([XYZA]):(-?\d+\.\d+)")
         matches = pattern.findall(res)
 
         position_data: Dict[str, float] = {}
@@ -261,7 +526,9 @@ class GCodeController(SerialController):
                 position_data[axis] = float(value_str)
             except ValueError:
                 self._logger.error(
-                    f"Failed to convert position value '{value_str}' for axis {axis} to float."
+                    "Failed to convert position value '%s' for axis %s to float.",
+                    value_str,
+                    axis,
                 )
                 continue
 
@@ -269,31 +536,33 @@ class GCodeController(SerialController):
 
     def sync_position(self) -> Tuple[bool, Dict[str, float]]:
         """
-        Queries the Qubot for its current machine position (M114) and
-        automatically adjusts the controller's internal 'current_position'
-        if a discrepancy is found.
+        Synchronize internal position with actual machine position.
+
+        Queries the machine position and compares it with the internal position.
+        If a discrepancy greater than the tolerance is found, attempts to correct
+        it by moving to the internal position.
 
         Returns:
-            Tuple[bool, Dict[str, float]]: A tuple where the first element
-            is True if a synchronization/adjustment occurred, and the second
-            is the final, synchronized position dictionary.
+            Tuple of (adjustment_occurred: bool, final_position: Dict[str, float])
+            where adjustment_occurred is True if a correction move was made.
+
+        Note:
+            This method may recursively call itself if a correction move is made.
         """
         self._logger.info("Starting position synchronization check (M114).")
 
-        # 1. Query the actual machine position
+        # Query the actual machine position
         queried_position = self.query_position()
 
-        # Check if the query was unsuccessful (only returns empty dict)
         if not queried_position:
             self._logger.warning("Query position failed. Cannot synchronize.")
             return False, self.current_position
 
-        # 2. Compare internal vs. queried position
+        # Compare internal vs. queried position
         axis_keys = ["X", "Y", "Z", "A"]
         adjustment_needed = False
 
         for axis in axis_keys:
-            # Check if axis exists in both dictionaries and if they differ significantly
             if (
                 axis in self.current_position
                 and axis in queried_position
@@ -301,25 +570,24 @@ class GCodeController(SerialController):
                 > self.TOLERANCE
             ):
                 self._logger.warning(
-                    f"Position mismatch found on {axis} axis: "
-                    f"Internal={self.current_position[axis]:.3f}, "
-                    f"Queried={queried_position[axis]:.3f}"
+                    "Position mismatch found on %s axis: Internal=%.3f, Queried=%.3f",
+                    axis,
+                    self.current_position[axis],
+                    queried_position[axis],
                 )
-
                 adjustment_needed = True
-
             elif axis in queried_position:
-                # Update internal position with actual queried position if it differs very slightly
+                # Update internal position with queried position if it differs slightly
                 self.current_position[axis] = queried_position[axis]
 
-        # 3. Perform Re-Synchronization Move if needed
+        # Perform re-synchronization move if needed
         if adjustment_needed:
             self._logger.info(
-                f"** DISCREPANCY DETECTED. Moving robot back to internal position: {self.current_position} **"
+                "** DISCREPANCY DETECTED. Moving robot back to internal position: %s **",
+                self.current_position,
             )
 
             try:
-                # Extract the X, Y, Z, A coordinates from the internal position for the move
                 target_x = self.current_position.get("X")
                 target_y = self.current_position.get("Y")
                 target_z = self.current_position.get("Z")
@@ -328,40 +596,37 @@ class GCodeController(SerialController):
                 self.move_absolute(x=target_x, y=target_y, z=target_z, a=target_a)
                 self._logger.info("Synchronization move successfully completed.")
 
-                # recursive call to verify position after move
-                self.sync_position()
-            except Exception as e:
-                self._logger.error(f"Synchronization move failed: {e}")
-                adjustment_needed = False  # Indicate failure in adjustment, though original discrepancy remains.
-
-        final_position = self.current_position.copy()
+                # Recursive call to verify position after move
+                return self.sync_position()
+            except (ValueError, RuntimeError, OSError) as e:
+                self._logger.error("Synchronization move failed: %s", e)
+                adjustment_needed = False
 
         if adjustment_needed:
             self._logger.info(
-                f"Position check complete. Internal position is synchronized with machine."
+                "Position check complete. Internal position is synchronized with machine."
             )
         else:
             self._logger.info("No adjustment was made.")
 
-        # Note: If adjustment_needed was True, it means a move was attempted.
-        # We return the initial state of adjustment_needed (i.e., if a move was triggered).
-        return adjustment_needed, final_position
+        return adjustment_needed, self.current_position.copy()
 
     def get_info(self) -> str:
         """
-        Queries the Qubot for machine information (M115 command).
+        Query machine information (M115 command).
 
         Returns:
-            str: The machine information string.
+            Machine information string from the device
         """
         self._logger.info("Querying machine information (M115).")
-        self._send_command(self._build_command("M115"))
-        res: str = self._read_response()
-        return res
+        return self.execute(self._build_command("M115"))
 
     def get_internal_position(self) -> Dict[str, float]:
         """
-        Returns the internally tracked position.
+        Get the internally tracked position.
+
+        Returns:
+            Dictionary containing the current internal position for all axes
         """
-        self._logger.debug(f"Returning internal position: {self.current_position}")
-        return self.current_position
+        self._logger.debug("Returning internal position: %s", self.current_position)
+        return self.current_position.copy()