robotframework-parrot-touchcontroller 1.0.0__tar.gz → 1.0.1__tar.gz

{robotframework_parrot_touchcontroller-1.0.0 → robotframework_parrot_touchcontroller-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.0
+Version: 1.0.1
 Summary: Touch control api to use within the Robot Framework ecosystem
 Author-email: Zilogic Systems <code@zilogic.com>
 License-Expression: Apache-2.0
@@ -9,9 +9,9 @@ Project-URL: Repository, https://github.com//zilogic-systems/parrot.git
 Project-URL: Issues, https://github.com/zilogic-systems/parrot/issues
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: robotframework
-Requires-Dist: pyyaml
-Requires-Dist: robotframework-parrot-adbcontroller
+Requires-Dist: robotframework~=7.3.2
+Requires-Dist: pyyaml~=6.0.2
+Requires-Dist: robotframework-parrot-adbcontroller~=1.0.0
 
 # Touch Controller
 

{robotframework_parrot_touchcontroller-1.0.0 → robotframework_parrot_touchcontroller-1.0.1}/parrot/TouchController.py

@@ -144,11 +144,11 @@ class TouchController:
         print(f"[INFO] Loaded controllers: {list(self.devices.keys())}")
 
     @keyword("Tap")
-    def send_touch(self, device: str, x: float, y: float, tap_time: float = 0.2) -> None:
+    def send_touch(self, device: str, x: float, y: float, tap_time: float) -> None:
         """
         Simulates a tap action on the given device at specified screen coordinates.
         Requires the device name, X and Y coordinates in pixels, and an 
-        optional tap duration (default: 0.2 seconds). 
+        tap duration. 
 
         *Syntax*
 

robotframework_parrot_touchcontroller-1.0.1/parrot/touch/axitouch.py

@@ -0,0 +1,343 @@
+# pylint: disable=no-member
+
+from robot.api.deco import keyword
+from parrot.touch.base import BaseTouch,Error
+from typing import Tuple, Any
+import yaml
+import os
+import tkinter as tk
+from tkinter import messagebox
+
+import xmlrpc.client
+
+
+class AxiTouchError(Exception):
+    """Represents an error in the AxiDrawTouch controller."""
+
+
+class AxiDrawTouch(BaseTouch):
+    """A touch controller implementation using the AxiDraw plotting device.
+
+    This class provides methods to simulate touch gestures such as tap and swipe
+    by controlling an AxiDraw plotter based on screen coordinates.
+    """
+
+    PROPERTIES = ["auto_home"]
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        """Initializes the AxiDraw touch controller.
+
+        The configuration dictionary must contain:
+        - `width`: screen width in pixels
+        - `height`: screen height in pixels
+        - `start_pos`: tuple (x, y) of starting cartesian coordinates (in inches)
+        - `end_pos`: tuple (x, y) of ending cartesian coordinates (in inches)
+
+        Raises:
+            AxiTouchError: If initialization or connection to AxiDraw fails.
+        """
+
+        try:
+            uri = f"http://{config['host']}:{config['port']}"
+            self.screen_width_px: int = config["width"]
+            self.screen_height_px: int = config["height"]
+            self.auto_home = False   # Flag to track auto-home behavior
+            self.calibration_file: str = config["calibration_data"]
+            self.device_name = config.get("device_name")
+            self.start_x_pos = None
+            self.start_y_pos = None
+            self.end_x_pos = None
+            self.end_y_pos = None
+            self.start_position = None
+            self.end_position = None
+
+            # Optional: configure pen heights and speed
+            pen_pos_up = 75
+            pen_pos_down = 40
+            speed_pendown = 100
+            speed_penup = 100
+            accel = 75
+
+            self.axi = xmlrpc.client.ServerProxy(uri)
+
+            self.axi.connect(accel,
+                pen_pos_up, pen_pos_down,
+                speed_penup, speed_pendown)
+            self._load_calibration_data()
+
+        except KeyError as err:
+            raise Error(f"Missing required configuration key: {err}") from err
+        except Exception as err:
+            raise Error(f"Initialization failed: {err}") from err
+
+    def _load_calibration_data(self):
+        """Load start and end Cartesian positions from calibration YAML."""
+        if not os.path.exists(self.calibration_file):
+            raise FileNotFoundError(
+                f"Calibration file '{self.calibration_file}' not found. "
+                f"Please perform calibration to get the start and end positions."
+            )
+
+        try:
+            with open(self.calibration_file, 'r') as file:
+                config = yaml.safe_load(file) or {}
+        except yaml.YAMLError as e:
+            raise ValueError(
+                f"Error reading YAML from '{self.calibration_file}': {e}"
+            )
+
+        if "start_position" not in config or "end_position" not in config:
+            raise KeyError(
+                "Missing 'start_position' or 'end_position' in calibration file. "
+                "Please perform calibration again."
+            )
+
+        self.cartesian_start = tuple(config["start_position"])
+        self.cartesian_end = tuple(config["end_position"])
+
+    def convert_to_inches(self, x: float, y: float) -> Tuple[float, float]:
+        """Convert screen coordinates (x, y) in pixels to Cartesian coordinates in inches.
+
+        *Args:*
+            `x` (float): X-coordinate in pixels.
+            `y` (float): Y-coordinate in pixels.
+
+        *Returns:*
+            `Tuple[float, float]`: Corresponding Cartesian coordinates (x, y) in inches.
+
+        *Raises:*
+            ValueError: If the screen coordinates are out of bounds or if calibration data is missing.
+
+        *NOTE:*
+            This method is valid only when the screen X-axis maps to the robot Y-axis and the screen Y-axis maps to the robot X-axis, as shown below.
+
+                    Robot Y
+                    +-----------------------------+
+                    |          Screen X           |
+            Robot X |    +-------------------+    |
+                    |    |                   | Screen Y
+                    |    +-------------------+    |
+                    |                             |
+                    +-----------------------------+
+
+        """
+
+        x = float(x)
+        y = float(y)
+
+        sx, sy = self.cartesian_start
+        ex, ey = self.cartesian_end
+
+        nx = y
+        ny = x
+
+        norm_w = self.screen_height_px   # 720
+        norm_h = self.screen_width_px   # 1920
+
+        x_scale = (ex - sx) / norm_w
+        y_scale = (ey - sy) / norm_h
+
+        robot_x = sx + nx * x_scale
+        robot_y = sy + ny * y_scale
+
+        return round(robot_x, 3), round(robot_y, 3)
+
+    def _validate_screen_coordinates(self, x: float, y: float) -> None:
+        """Validate that the screen coordinates are within the configured display."""
+
+        if not (0 <= x <= self.screen_width_px):
+            raise Error(
+                f"Touch tap failed at ({x}, {y}) due to out-of-bound coordinates"
+            )
+
+        if not (0 <= y <= self.screen_height_px):
+            raise Error(
+                f"Touch tap failed at ({x}, {y}) due to out-of-bound coordinates"
+            )
+
+
+    def touch_init(self) -> None:
+        """Initialize the pen by lifting it up and moving to origin (0, 0).
+
+        Raises:
+            AxiTouchError: If initialization movement fails.
+        """
+
+        try:
+            self.axi.penup()
+            self.axi.home()
+            print("AxiDrawTouch: Initialized and moved to origin")
+        except Exception as err:
+            raise Error("Initialization failed") from err
+
+    def touch_tap(self, x: float, y: float, tap_time) -> None:
+        """Simulate a tap at the given screen coordinates.
+
+        Args:
+            x (int | float): X-coordinate in pixels.
+            y (int | float): Y-coordinate in pixels.
+            tap_time (float): Duration to hold pen down.
+        Raises:
+            AxiTouchError: If the tap operation fails.
+        """
+
+        try:
+            x = float(x)
+            y = float(y)
+            self._validate_screen_coordinates(x, y)
+            px, py = self.convert_to_inches(x, y)
+            print(px, py)
+            self.axi.tap(px, py, tap_time)
+            if self.auto_home:
+                self.axi.home()
+            print(f"AxiDrawTouch: Tap at ({x}, {y}) for {tap_time}s")
+        except Error:
+            raise
+        except Exception as err:
+            raise Error(f"Touch tap failed at ({x}, {y})") from err
+
+    def touch_swipe(
+        self,
+        startx: float,
+        starty: float,
+        endx: float,
+        endy: float
+    ) -> None:
+        """Simulate a swipe gesture from start to end coordinates.
+
+        Args:
+            startx (int | float): Start X-coordinate in pixels.
+            starty (int | float): Start Y-coordinate in pixels.
+            endx (int | float): End X-coordinate in pixels.
+            endy (int | float): End Y-coordinate in pixels.
+            swipe_time (float): Duration of the swipe.
+
+        Raises:
+            AxiTouchError: If the swipe operation fails.
+        """
+
+        try:
+            startx = float(startx)
+            starty = float(starty)
+            endx = float(endx)
+            endy = float(endy)
+            self._validate_screen_coordinates(startx, starty)
+            self._validate_screen_coordinates(endx, endy)
+            psx, psy = self.convert_to_inches(startx, starty)
+            pex, pey = self.convert_to_inches(endx, endy)
+            self.axi.swipe(psx, psy, pex, pey)
+
+            print(
+                f"AxiDrawTouch: Swipe from "f"({startx}, {starty}) to ({endx}, {endy})")
+
+        except Error:
+            raise
+
+        except Exception as err:
+            raise Error(
+                f"Swipe failed from "
+                f"({startx}, {starty}) to ({endx}, {endy})") from err
+
+
+    def move(self, x: float, y: float):
+        """
+        Moving Axi arm to the absolute position in axi usable
+        area. where x and y are inches.
+        """
+        try:
+            if x == 0 and y == 0:
+                self.axi.home()
+                return
+            self.axi.move(x, y)
+        except Exception as err:
+            raise Error(f"Failed to Move pointing device from ({x}, {y})") from err
+
+    def home(self):
+        """Returns the touch to its home default position."""
+        try:
+            self.axi.home_with_limit_switch()
+        except Exception as err:
+            raise Error(f"Failed to Home pointing device") from err
+
+    def wait_for_ok(self, message):
+        root = tk.Tk()
+        root.withdraw()
+        messagebox.showinfo("Position Calculation", message)
+        root.destroy()
+
+    def calibrate(self):
+        """Returns the calibration for start and end position"""
+        try:
+
+            self.start_x_pos, self.start_y_pos = self._calibrate_corner(f"Move the TouchBot arm to the top-left corner of {self.device_name}. Click OK to continue.")
+
+            self.end_x_pos, self.end_y_pos = self._calibrate_corner(f"Move the TouchBot arm to the bottom-right corner of {self.device_name}. Click OK to continue.")
+
+            self.save_calibrate_position()
+
+        except Exception as err:
+            raise Error("Failed to Calibrate the device") from err
+
+    def _calibrate_corner(self, message: str):
+        self.axi.disconnect()
+        self.wait_for_ok(message)
+        self.axi.connect()
+        x, y = self.axi.calibrate_with_limit_switch()
+        return round(abs(x), 2), round(abs(y), 2)
+
+
+    def save_calibrate_position(self):
+        try:
+            calibrate_position = {}
+
+            if not os.path.exists(self.calibration_file):
+                pass
+            else:
+                with open(self.calibration_file, "r") as file:
+                    loaded_file = yaml.safe_load(file)
+                    if isinstance(loaded_file, dict):
+                        calibrate_position = loaded_file
+
+            calibrate_position["start_position"] = [self.start_x_pos, self.start_y_pos]
+            calibrate_position["end_position"] = [self.end_x_pos, self.end_y_pos]
+
+            with open(self.calibration_file, "w") as file:
+                yaml.safe_dump(calibrate_position, file, sort_keys=False)
+
+            print("YAML file updated successfully.")
+
+        except Exception as err:
+            raise Error(f"Error saving ArUco points: {err}") from err
+
+
+    def touch_command(self, cmd, *args):
+        """Executes a backend-specific touch command on the given device controller."""
+        cmd = cmd.lower()
+        if cmd == "move":
+            if len(args) != 2:
+                raise Error("move command expects x and y as argument")
+            x = float(args[0])
+            y = float(args[1])
+            self.move(x, y)
+        elif cmd == "home":
+            self.home()
+        elif cmd == "calibrate":
+            self.calibrate()
+        else:
+            raise Error(f"Invalid command {cmd}")
+
+    def set_param(self, param: str, value: bool) -> None:
+        """
+        Set a runtime parameter for ArucoCapture.
+
+        | *Arguments*    | *Description* |
+        | `param (str)`  | Supported: `auto_home`. |
+        | `value (bool)` | True or False Value Supported. |
+
+        *Raises:*
+        | `Error` | If an unsupported parameter is provided. |
+        """
+        if param == 'auto_home' and param in self.PROPERTIES:
+            self.auto_home = value
+        else:
+            raise Error(f"ArucoCapture Error: Unsupported parameter: {param}")

{robotframework_parrot_touchcontroller-1.0.0 → robotframework_parrot_touchcontroller-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robotframework-parrot-touchcontroller"
-version = "1.0.0"
+version = "1.0.1"
 description = "Touch control api to use within the Robot Framework ecosystem"
 authors = [
   { name = "Zilogic Systems", email = "code@zilogic.com" },
@@ -13,9 +13,9 @@ requires-python = ">=3.6"
 readme = "README.md"
 license = "Apache-2.0"
 dependencies = [
-  "robotframework",
-  "pyyaml",
-  "robotframework-parrot-adbcontroller"
+  "robotframework~=7.3.2",
+  "pyyaml~=6.0.2",
+  "robotframework-parrot-adbcontroller~=1.0.0"
   ]
 
 

{robotframework_parrot_touchcontroller-1.0.0 → robotframework_parrot_touchcontroller-1.0.1}/robotframework_parrot_touchcontroller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.0
+Version: 1.0.1
 Summary: Touch control api to use within the Robot Framework ecosystem
 Author-email: Zilogic Systems <code@zilogic.com>
 License-Expression: Apache-2.0
@@ -9,9 +9,9 @@ Project-URL: Repository, https://github.com//zilogic-systems/parrot.git
 Project-URL: Issues, https://github.com/zilogic-systems/parrot/issues
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: robotframework
-Requires-Dist: pyyaml
-Requires-Dist: robotframework-parrot-adbcontroller
+Requires-Dist: robotframework~=7.3.2
+Requires-Dist: pyyaml~=6.0.2
+Requires-Dist: robotframework-parrot-adbcontroller~=1.0.0
 
 # Touch Controller
 

robotframework_parrot_touchcontroller-1.0.1/robotframework_parrot_touchcontroller.egg-info/requires.txt

@@ -0,0 +1,3 @@
+robotframework~=7.3.2
+pyyaml~=6.0.2
+robotframework-parrot-adbcontroller~=1.0.0

robotframework_parrot_touchcontroller-1.0.0/parrot/touch/axitouch.py

@@ -1,185 +0,0 @@
-from robot.api.deco import keyword
-from parrot.touch.base import BaseTouch,Error
-from typing import Tuple, Any
-
-import xmlrpc.client
-
-
-class AxiTouchError(Exception):
-    """Represents an error in the AxiDrawTouch controller."""
-
-
-class AxiDrawTouch(BaseTouch):
-    """A touch controller implementation using the AxiDraw plotting device.
-
-    This class provides methods to simulate touch gestures such as tap and swipe
-    by controlling an AxiDraw plotter based on screen coordinates.
-    """
-
-    PROPERTIES = ["auto_home"]
-
-    def __init__(self, config: dict[str, Any]) -> None:
-        """Initializes the AxiDraw touch controller.
-
-        The configuration dictionary must contain:
-        - `width`: screen width in pixels
-        - `height`: screen height in pixels
-        - `start_pos`: tuple (x, y) of starting cartesian coordinates (in inches)
-        - `end_pos`: tuple (x, y) of ending cartesian coordinates (in inches)
-
-        Raises:
-            AxiTouchError: If initialization or connection to AxiDraw fails.
-        """
-
-        try:
-            uri = f"http://{config['host']}:{config['port']}"
-            self.screen_width_px: int = config["width"]
-            self.screen_height_px: int = config["height"]
-            self.cartesian_start: Tuple[float, float] = config["start_pos"]
-            self.cartesian_end: Tuple[float, float] = config["end_pos"]
-
-            self.auto_home = False   # Flag to track auto-home behavior
-
-            # Optional: configure pen heights and speed
-            pen_pos_up = 75
-            pen_pos_down = 40
-            speed_pendown = 100
-            speed_penup = 100
-            accel = 75
-
-            self.axi = xmlrpc.client.ServerProxy(uri)
-
-            self.axi.connect(accel,
-                pen_pos_up, pen_pos_down,
-                speed_penup, speed_pendown)
-
-        except KeyError as err:
-            raise Error(f"Missing required configuration key: {err}") from err
-        except Exception as err:
-            raise Error(f"Initialization failed: {err}") from err
-
-    def convert_to_inches(self, x: float, y: float) -> Tuple[float, float]:
-            x = float(x)
-            y = float(y)
-            sx, sy = self.cartesian_start
-            ex, ey = self.cartesian_end
-            x_scale = (ex - sx) / self.screen_width_px
-            y_scale = (ey - sy) / self.screen_height_px
-            return round(sx + x * x_scale, 3), round(sy + y * y_scale, 3)
-
-
-    def touch_init(self) -> None:
-        """Initialize the pen by lifting it up and moving to origin (0, 0).
-
-        Raises:
-            AxiTouchError: If initialization movement fails.
-        """
-
-        try:
-            self.axi.penup()
-            self.axi.home()
-            print("AxiDrawTouch: Initialized and moved to origin")
-        except Exception as err:
-            raise Error("Initialization failed") from err
-
-    def touch_tap(self, x: float, y: float, tap_time) -> None:
-        """Simulate a tap at the given screen coordinates.
-
-        Args:
-            x (int | float): X-coordinate in pixels.
-            y (int | float): Y-coordinate in pixels.
-            tap_time (float, optional): Duration to hold pen down. Defaults to 0.2s.
-
-        Raises:
-            AxiTouchError: If the tap operation fails.
-        """
-
-        try:
-            px, py = self.convert_to_inches(x, y)
-            print(px, py)
-            self.axi.tap(px, py, tap_time)
-            if self.auto_home:
-                self.axi.home()
-            print(f"AxiDrawTouch: Tap at ({x}, {y}) for {tap_time}s")
-        except Exception as err:
-            raise Error(f"Touch tap failed at ({x}, {y})") from err
-
-    def touch_swipe(
-        self,
-        startx: float,
-        starty: float,
-        endx: float,
-        endy: float
-    ) -> None:
-        """Simulate a swipe gesture from start to end coordinates.
-
-        Args:
-            startx (int | float): Start X-coordinate in pixels.
-            starty (int | float): Start Y-coordinate in pixels.
-            endx (int | float): End X-coordinate in pixels.
-            endy (int | float): End Y-coordinate in pixels.
-            swipe_time (float, optional): Duration of the swipe. Defaults to 0.2s.
-
-        Raises:
-            AxiTouchError: If the swipe operation fails.
-        """
-
-        try:
-            psx, psy = self.convert_to_inches(startx, starty)
-            pex, pey = self.convert_to_inches(endx, endy)
-            self.axi.swipe(psx, psy, pex, pey)
-            print(f"AxiDrawTouch: Swipe from ({startx}, {starty}) to ({endx}, {endy})")
-        except Exception as err:
-            raise Error(f"Swipe failed from ({startx}, {starty}) to ({endx}, {endy})") from err
-
-
-    def move(self, x: float, y: float):
-        """
-        Moving Axi arm to the absolute position in axi usable
-        area. where x and y are inches.
-        """
-        try:
-            if x == 0 and y == 0:
-                self.axi.home()
-                return
-            self.axi.move(x, y)
-        except Exception as err:
-            raise Error(f"Failed to Move pointing device from ({x}, {y})") from err
-
-    def home(self):
-        """Returns the touch to its home default position."""
-        try:
-            self.axi.home_with_limit_switch()
-        except Exception as err:
-            raise Error(f"Failed to Home pointing device") from err
-
-    def touch_command(self, cmd, *args):
-        """Executes a backend-specific touch command on the given device controller."""
-        cmd = cmd.lower()
-        if cmd == "move":
-            if len(args) != 2:
-                raise Error("move command expects x and y as argument")
-            x = float(args[0])
-            y = float(args[1])
-            self.move(x, y)
-        elif cmd == "home":
-            self.home()
-
-        else:
-            raise Error(f"Invalid command {cmd}")
-
-    def set_param(self, param: str, value: bool) -> None:
-        """
-        Set a runtime parameter for ArucoCapture.
-
-        | *Arguments*    | *Description* |
-        | `param (str)`  | Supported: `auto_home`. |
-        | `value (bool)` | True or False Value Supported. |
-
-        *Raises:*
-        | `Error` | If an unsupported parameter is provided. |
-        """
-        if param == 'auto_home' and param in self.PROPERTIES:
-            self.auto_home = value
-        else:
-            raise Error(f"ArucoCapture Error: Unsupported parameter: {param}")

robotframework_parrot_touchcontroller-1.0.0/robotframework_parrot_touchcontroller.egg-info/requires.txt

@@ -1,3 +0,0 @@
-robotframework
-pyyaml
-robotframework-parrot-adbcontroller