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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.0
+Version: 1.1.0
 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.1.0}/parrot/TouchController.py

@@ -17,9 +17,9 @@ class TouchController:
 
     == Configuration ==
 
-    Touch devices are configured using the `Touch Setup` keyword with a dictionary 
-    typically loaded from a YAML file (e.g. `config.yaml`) by importing the library 
-    and variables into your test suite. Each entry in the configuration must include 
+    Touch devices are configured using the `Touch Setup` keyword with a dictionary
+    typically loaded from a YAML file (e.g. `config.yaml`) by importing the library
+    and variables into your test suite. Each entry in the configuration must include
     a `type` field that specifies the device type. Supported types include:
 
     - `UsbHidTouch`: USB HID-based touch simulation over TCP.
@@ -44,7 +44,7 @@ class TouchController:
     === ADBTouch ===
       Simulates touch events on an Android device using ADB commands.
       Supported configs:
-      - `ip`: IP address of the Android device (e.g., `192.168.43.168`)
+      - `type`: ADBTouch
 
     === Configuration Sample (config.yaml) ===
 
@@ -69,12 +69,11 @@ class TouchController:
     |
     |   T3:
     |     type: ADBTouch
-    |     ip: 192.168.43.168
 
     = General Usage =
 
-    Setup and initialize touch devices from a YAML configuration. Simulate touch input such as tap and swipe gestures 
-    across multiple supported devices. This library supports both real physical systems and simulated touch environments, 
+    Setup and initialize touch devices from a YAML configuration. Simulate touch input such as tap and swipe gestures
+    across multiple supported devices. This library supports both real physical systems and simulated touch environments,
     making it suitable for automated device interaction and UI testing.
 
     = Example =
@@ -102,7 +101,7 @@ class TouchController:
     @keyword("Touch Setup")
     def setup(self, config: Dict[str, Dict[str, Any]]) -> None:
         """Initializes and configures touch controller devices.
-        Loads controller instances from the given `Configuration` dictionary 
+        Loads controller instances from the given `Configuration` dictionary
         and prepares them for input simulation.
 
         *Syntax*
@@ -144,11 +143,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). 
+        Requires the device name, X and Y coordinates in pixels, and an
+        tap duration.
 
         *Syntax*
 
@@ -197,11 +196,11 @@ class TouchController:
         """
         Executes a backend-specific touch command on the given device controller.
 
-        This keyword is used to send a command (e.g., `Move`, `Home`) to a specific device. 
-        The available commands and required arguments depends on the backend implementation 
+        This keyword is used to send a command (e.g., `Move`, `Home`) to a specific device.
+        The available commands and required arguments depends on the backend implementation
         of the touch controller. Currently only the AxiDrawTouch backend has commands.
 
-        AxiDrawTouch backend supports the following commands. 
+        AxiDrawTouch backend supports the following commands.
 
         - `Move` — Moves to the specified position (in inches) without touching.
           Requires two arguments: `x`, `y`.
@@ -228,12 +227,12 @@ class TouchController:
     def set_param_auto_home(self, device: str, param: str, value: str) -> None:
         """
         Sets values to configure runtime parameters for Touch control devices.
-        
+
         Currently, this keyword supports only for `AxiDrawTouch` type devices,
 
         | *Parameter*       | *Description*                                                         | *Example Value* |
         | `auto_home`       | Specifies the touch action to be directed to the home position        | "True or False" |
-       
+
         *Syntax*
 
         | `Touch Set Param` | <DEVICE_NAME> | auto_home | <VALUE> |

{robotframework_parrot_touchcontroller-1.0.0 → robotframework_parrot_touchcontroller-1.1.0}/parrot/touch/adbtouch.py

@@ -1,4 +1,4 @@
-from parrot import ADBController
+from robot.libraries.BuiltIn import BuiltIn
 from parrot.touch.base import BaseTouch, Error
 
 class ADBTouch(BaseTouch):
@@ -12,20 +12,8 @@ class ADBTouch(BaseTouch):
     def __init__(self, config: dict):
         """
         Initializes the ADB touch controller.
-
-        The configuration dictionary must contain:
-        - `ip`: IP address of the ADB-connected device
-
-        Raises:
-            Error: If required configuration is missing or initialization fails.
         """
-        try:
-            self.device_ip = config["ip"]
-            self.adb = ADBController.ADBController()
-        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
+        self.adb = None
 
     def touch_init(self):
         """
@@ -35,10 +23,9 @@ class ADBTouch(BaseTouch):
             Error: If the device connection fails.
         """
         try:
-            self.adb.adb_ip_connect(self.device_ip)
-            print(f"ADBTouch: Connected to device {self.device_ip}")
+            self.adb = BuiltIn().get_library_instance("parrot.ADBController")
         except Exception as err:
-            raise Error("Initialization failed") from err
+            raise Error(f"ADB Touch Initialization failed: {err}") from err
 
     def touch_tap(self, x, y, tap_time):
         """
@@ -79,6 +66,6 @@ class ADBTouch(BaseTouch):
             print(f"ADBTouch: 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 touch_command(self, cmd, *args):
         raise Error("Commands are not supported by the ADBTouch backend")

robotframework_parrot_touchcontroller-1.1.0/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}")