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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.1
+Version: 1.0.2
 Summary: Touch control api to use within the Robot Framework ecosystem
 Author-email: Zilogic Systems <code@zilogic.com>
 License-Expression: Apache-2.0

{robotframework_parrot_touchcontroller-1.0.1 → robotframework_parrot_touchcontroller-1.0.2}/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.
@@ -40,11 +40,17 @@ class TouchController:
       - `width`, `height`: Touch surface resolution in pixels
       - `start_pos`: Physical start coordinates (e.g., `[0, 0]`)
       - `end_pos`: Physical end coordinates defining working area (e.g., `[8.66, 5.12]`)
+      - `orientation`: Defines how touchscreen pixel coordinates are mapped to
+        the AxiDraw's coordinate system (e.g., `landscape` or `portrait`).
+        - `landscape`: Screen X maps to Robot Y, Screen Y maps to Robot X.
+        - `portrait`: Screen X maps to Robot X, Screen Y maps to Robot Y.
+
+
 
     === 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) ===
 
@@ -66,15 +72,15 @@ class TouchController:
     |     height: 600
     |     start_pos: [0, 0]
     |     end_pos: [8.66, 5.12]
+    |     orientation: landscape
     |
     |   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 +108,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*
@@ -147,8 +153,8 @@ class TouchController:
     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 
-        tap duration. 
+        Requires the device name, X and Y coordinates in pixels, and an
+        tap duration.
 
         *Syntax*
 
@@ -197,11 +203,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 +234,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.1 → robotframework_parrot_touchcontroller-1.0.2}/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.0.1 → robotframework_parrot_touchcontroller-1.0.2}/parrot/touch/axitouch.py

@@ -50,6 +50,7 @@ class AxiDrawTouch(BaseTouch):
             self.end_y_pos = None
             self.start_position = None
             self.end_position = None
+            self.orientation = config.get("orientation")
 
             # Optional: configure pen heights and speed
             pen_pos_up = 75
@@ -101,6 +102,7 @@ class AxiDrawTouch(BaseTouch):
         *Args:*
             `x` (float): X-coordinate in pixels.
             `y` (float): Y-coordinate in pixels.
+            `orientation` (str): The orientation of the screen ('landscape' or 'portrait').
 
         *Returns:*
             `Tuple[float, float]`: Corresponding Cartesian coordinates (x, y) in inches.
@@ -109,36 +111,65 @@ class AxiDrawTouch(BaseTouch):
             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.
+            Use "landscape" 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
+                    |                             |
+                    |     Screen X                |
+                    |    +-------------------+    |
+            Robot X |    |                   | Screen Y
+                    |    |                   |    |
                     |    +-------------------+    |
                     |                             |
+                    |                             |
+                    |                             |
                     +-----------------------------+
 
+            Use "portrait" when the screen X-axis maps to the robot X-axis and
+            the screen Y-axis maps to the robot Y-axis, as shown below.
+
+
+                    Robot Y
+                    +-----------------------------+
+                    |    Screen Y                 |
+                    |    +-------+                |
+                    |    |       |                |
+            Robot X |    |       |                |
+                    |    |       | Screen X       |
+                    |    |       |                |
+                    |    |       |                |
+                    |    |       |                |
+                    |    +-------+                |
+                    +-----------------------------+
         """
 
         x = float(x)
         y = float(y)
 
+        if not self.orientation:
+            self.orientation = "landscape"
+
         sx, sy = self.cartesian_start
         ex, ey = self.cartesian_end
 
-        nx = y
-        ny = x
+        if self.orientation == 'landscape':
+            x_scale = (ex - sx) / self.screen_height_px
+            y_scale = (ey - sy) / self.screen_width_px
 
-        norm_w = self.screen_height_px   # 720
-        norm_h = self.screen_width_px   # 1920
+            robot_x = sx + y * x_scale
+            robot_y = sy + x * y_scale
 
-        x_scale = (ex - sx) / norm_w
-        y_scale = (ey - sy) / norm_h
+        elif self.orientation == 'portrait':
+            x_scale = (ex - sx) / self.screen_width_px
+            y_scale = (ey - sy) / self.screen_height_px
 
-        robot_x = sx + nx * x_scale
-        robot_y = sy + ny * y_scale
+            robot_x = sx + x * x_scale
+            robot_y = sy + y * y_scale
+
+        else:
+            raise ValueError("orientation must be either 'landscape' or 'portrait'")
 
         return round(robot_x, 3), round(robot_y, 3)
 
@@ -279,12 +310,17 @@ class AxiDrawTouch(BaseTouch):
             raise Error("Failed to Calibrate the device") from err
 
     def _calibrate_corner(self, message: str):
+        """Calibrate a corner and reconnect the AXI server afterward."""
         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)
+        try:
+            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)
 
+        finally:
+            self.axi.disconnect()
+            self.axi.connect()
 
     def save_calibrate_position(self):
         try:
@@ -340,4 +376,4 @@ class AxiDrawTouch(BaseTouch):
         if param == 'auto_home' and param in self.PROPERTIES:
             self.auto_home = value
         else:
-            raise Error(f"ArucoCapture Error: Unsupported parameter: {param}")
+            raise Error(f"ArucoCapture Error: Unsupported parameter: {param}")

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robotframework-parrot-touchcontroller"
-version = "1.0.1"
+version = "1.0.2"
 description = "Touch control api to use within the Robot Framework ecosystem"
 authors = [
   { name = "Zilogic Systems", email = "code@zilogic.com" },

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.1
+Version: 1.0.2
 Summary: Touch control api to use within the Robot Framework ecosystem
 Author-email: Zilogic Systems <code@zilogic.com>
 License-Expression: Apache-2.0