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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.0.1
+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

{robotframework_parrot_touchcontroller-1.0.1 → 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*
@@ -147,8 +146,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 +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.1 → 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/axitouchserial.py

@@ -0,0 +1,1147 @@
+# 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
+
+from __future__ import division
+from __future__ import print_function
+
+from bisect import bisect
+from collections import namedtuple
+from math import sqrt, hypot, modf
+
+from serial import Serial
+from serial.tools.list_ports import comports
+
+TIMESLICE_MS = 10
+
+MICROSTEPPING_MODE = 1
+STEP_DIVIDER = 2 ** (MICROSTEPPING_MODE - 1)
+
+STEPS_PER_INCH = 2032 / STEP_DIVIDER
+STEPS_PER_MM = 80 / STEP_DIVIDER
+
+PEN_UP_POSITION = 60
+PEN_UP_SPEED = 150
+PEN_UP_DELAY = 0
+
+PEN_DOWN_POSITION = 40
+PEN_DOWN_SPEED = 150
+PEN_DOWN_DELAY = 0
+
+ACCELERATION = 16
+MAX_VELOCITY = 4
+CORNER_FACTOR = 0.001
+
+JOG_ACCELERATION = 16
+JOG_MAX_VELOCITY = 8
+
+VID_PID = '04D8:FD92'
+
+EPS = 1e-9
+
+
+
+class AxiTouchSerialError(Exception):
+    """Represents an error in the AxiDrawTouch controller."""
+
+
+class AxiDrawTouchSerial(BaseTouch):
+    """A touch controller implementation using the AxiDraw plotting device 
+    connected by serial.
+
+    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}")
+
+
+def path_length(points):
+    result = 0
+    for (x1, y1), (x2, y2) in zip(points, points[1:]):
+        result += hypot(x2 - x1, y2 - y1)
+    return result
+
+class Planner(object):
+    """A planner computes a motion
+    profile for a list of (x, y) points"""
+    def __init__(self, acceleration, max_velocity, corner_factor):
+        self.acceleration = acceleration
+        self.max_velocity = max_velocity
+        self.corner_factor = corner_factor
+
+    def plan(self, points):
+        return constant_acceleration_plan(
+            points, self.acceleration, self.max_velocity, self.corner_factor)
+
+    def plan_all(self, paths):
+        return [self.plan(path) for path in paths]
+
+class Plan(object):
+    """A plan is a motion profile generated
+    by the planner"""
+    def __init__(self, blocks):
+        self.blocks = blocks
+        self.ts = [] # start time of each block
+        self.ss = [] # start distance of each block
+        t = 0
+        s = 0
+        for b in blocks:
+            self.ts.append(t)
+            self.ss.append(s)
+            t += b.t
+            s += b.s
+        self.t = t # total time
+        self.s = s # total duration
+
+    def instant(self, t):
+        t = max(0, min(self.t, t)) # clamp t
+        i = bisect(self.ts, t) - 1 # find block for t
+        return self.blocks[i].instant(t - self.ts[i], self.ts[i], self.ss[i])
+
+class Block(object):
+    """
+    A block is a constant acceleration for a duration of time
+    """
+    def __init__(self, a, t, vi, p1, p2):
+        self.a = a
+        self.t = t
+        self.vi = vi
+        self.p1 = p1
+        self.p2 = p2
+        self.s = p1.distance(p2)
+
+    def instant(self, t, dt=0, ds=0):
+        t = max(0, min(self.t, t)) # clamp t
+        a = self.a
+        v = self.vi + self.a * t
+        s = self.vi * t + self.a * t * t / 2
+        s = max(0, min(self.s, s)) # clamp s
+        p = self.p1.lerps(self.p2, s)
+        return Instant(t + dt, p, s + ds, v, a)
+
+# An instant gives position, velocity, etc. at a single point in time
+Instant = namedtuple('Instant', ['t', 'p', 's', 'v', 'a'])
+
+# a = acceleration
+# v = velocity
+# s = distance
+# t = time
+# i = initial
+# f = final
+
+_Point = namedtuple('Point', ['x', 'y'])
+
+class Point(_Point):
+    def length(self):
+        return hypot(self.x, self.y)
+
+    def normalize(self):
+        d = self.length()
+        if d == 0:
+            return Point(0, 0)
+        return Point(self.x / d, self.y / d)
+
+    def distance(self, other):
+        return hypot(self.x - other.x, self.y - other.y)
+
+    def distance_squared(self, other):
+        return (self.x - other.x) ** 2 + (self.y - other.y) ** 2
+
+    def add(self, other):
+        return Point(self.x + other.x, self.y + other.y)
+
+    def sub(self, other):
+        return Point(self.x - other.x, self.y - other.y)
+
+    def mul(self, factor):
+        return Point(self.x * factor, self.y * factor)
+
+    def dot(self, other):
+        return self.x * other.x + self.y * other.y
+
+    def lerps(self, other, s):
+        v = other.sub(self).normalize()
+        return self.add(v.mul(s))
+
+    def segment_distance(self, v, w):
+        p = self
+        l2 = v.distance_squared(w)
+        if l2 == 0:
+            return p.distance(v)
+        t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2
+        t = max(0, min(1, t))
+        x = v.x + t * (w.x - v.x)
+        y = v.y + t * (w.y - v.y)
+        q = Point(x, y)
+        return p.distance(q)
+
+Triangle = namedtuple('Triangle',
+    ['s1', 's2', 't1', 't2', 'vmax', 'p1', 'p2', 'p3'])
+
+def triangle(s, vi, vf, a, p1, p3):
+    # compute a triangular profile: accelerating, decelerating
+    s1 = (2 * a * s + vf * vf - vi * vi) / (4 * a)
+    s2 = s - s1
+    vmax = (vi * vi + 2 * a * s1) ** 0.5
+    t1 = (vmax - vi) / a
+    t2 = (vf - vmax) / -a
+    p2 = p1.lerps(p3, s1)
+    return Triangle(s1, s2, t1, t2, vmax, p1, p2, p3)
+
+Trapezoid = namedtuple('Trapezoid',
+    ['s1', 's2', 's3', 't1', 't2', 't3', 'p1', 'p2', 'p3', 'p4'])
+
+def trapezoid(s, vi, vmax, vf, a, p1, p4):
+    # compute a trapezoidal profile: accelerating, cruising, decelerating
+    t1 = (vmax - vi) / a
+    s1 = (vmax + vi) / 2 * t1
+    t3 = (vf - vmax) / -a
+    s3 = (vf + vmax) / 2 * t3
+    s2 = s - s1 - s3
+    t2 = s2 / vmax
+    p2 = p1.lerps(p4, s1)
+    p3 = p1.lerps(p4, s - s3)
+    return Trapezoid(s1, s2, s3, t1, t2, t3, p1, p2, p3, p4)
+
+def corner_velocity(s1, s2, vmax, a, delta):
+    """
+    Compute a maximum velocity at the corner of two segments
+    https://onehossshay.wordpress.com/2011/09/24/improving_grbl_cornering_algorithm/
+    """
+    cosine = -s1.vector.dot(s2.vector)
+    if abs(cosine - 1) < EPS:
+        return 0
+    sine = sqrt((1 - cosine) / 2)
+    if abs(sine - 1) < EPS:
+        return vmax
+    v = sqrt((a * delta * sine) / (1 - sine))
+    return min(v, vmax)
+
+
+class Segment(object):
+    """
+    A segment is a line segment between two points, which will be broken
+    up into blocks by the planner
+    """
+    def __init__(self, p1, p2):
+        self.p1 = p1
+        self.p2 = p2
+        self.length = p1.distance(p2)
+        self.vector = p2.sub(p1).normalize()
+        self.max_entry_velocity = 0
+        self.entry_velocity = 0
+        self.blocks = []
+
+class Throttler(object):
+    def __init__(self, points, vmax, dt, threshold):
+        self.points = points
+        self.vmax = vmax
+        self.dt = dt
+        self.threshold = threshold
+        self.distances = []
+        prev = points[0]
+        d = 0
+        for point in points:
+            d += prev.distance(point)
+            self.distances.append(d)
+            prev = point
+
+    def lookup(self, d):
+        return bisect(self.distances, d) - 1
+
+    def is_feasible(self, i0, v):
+        d = v * self.dt
+        x0 = self.distances[i0]
+        x1 = x0 + d
+        i1 = self.lookup(x1)
+        if i0 == i1:
+            return True
+        p0 = self.points[i0]
+        p10 = self.points[i1]
+        try:
+            p11 = self.points[i1+1]
+        except IndexError:
+            p11 = p10
+        s = x1 - self.distances[i1]
+        p1 = p10.lerps(p11, s)
+        i = i0 + 1
+        while i <= i1:
+            p = self.points[i]
+            if p.segment_distance(p0, p1) > self.threshold:
+                return False
+            i += 1
+        return True
+
+    def compute_max_velocity(self, index):
+        if self.is_feasible(index, self.vmax):
+            return self.vmax
+        lo = 0
+        hi = self.vmax
+        for _ in range(16):
+            v = (lo + hi) / 2
+            if self.is_feasible(index, v):
+                lo = v
+            else:
+                hi = v
+        v = lo
+        return v
+
+    def compute_max_velocities(self):
+        return [self.compute_max_velocity(i) for i in range(len(self.points))]
+
+def constant_acceleration_plan(points, a, vmax, cf):
+    # make sure points are Point objects
+    points = [Point(x, y) for x, y in points]
+
+    # the throttler reduces speeds based on the discrete timeslicing nature of
+    # the device
+    # TODO: expose parameters
+    throttler = Throttler(points, vmax, 0.02, 0.001)
+    max_velocities = throttler.compute_max_velocities()
+
+    # create segments for each consecutive pair of points
+    segments = [Segment(p1, p2) for p1, p2 in zip(points, points[1:])]
+
+    # compute a max_entry_velocity for each segment
+    # based on the angle formed by the two segments at the vertex
+    for v, s1, s2 in zip(max_velocities, segments, segments[1:]):
+        s1.max_entry_velocity = min(s1.max_entry_velocity, v)
+        s2.max_entry_velocity = corner_velocity(s1, s2, vmax, a, cf)
+
+    # add a dummy segment at the end to force a final velocity of zero
+    segments.append(Segment(points[-1], points[-1]))
+
+    # loop over segments
+    i = 0
+    while i < len(segments) - 1:
+        # pull out some variables
+        segment = segments[i]
+        next_segment = segments[i + 1]
+        s = segment.length
+        vi = segment.entry_velocity
+        vexit = next_segment.max_entry_velocity
+        p1 = segment.p1
+        p2 = segment.p2
+
+        # determine which profile to use for this segment
+        m = triangle(s, vi, vexit, a, p1, p2)
+        if m.s1 < -EPS:
+            # too fast! update max_entry_velocity and backtrack
+            segment.max_entry_velocity = sqrt(vexit * vexit + 2 * a * s)
+            i -= 1
+        elif m.s2 < 0:
+            # accelerate
+            vf = sqrt(vi * vi + 2 * a * s)
+            t = (vf - vi) / a
+            segment.blocks = [
+                Block(a, t, vi, p1, p2),
+            ]
+            next_segment.entry_velocity = vf
+            i += 1
+        elif m.vmax > vmax:
+            # accelerate, cruise, decelerate
+            z = trapezoid(s, vi, vmax, vexit, a, p1, p2)
+            segment.blocks = [
+                Block(a, z.t1, vi, z.p1, z.p2),
+                Block(0, z.t2, vmax, z.p2, z.p3),
+                Block(-a, z.t3, vmax, z.p3, z.p4),
+            ]
+            next_segment.entry_velocity = vexit
+            i += 1
+        else:
+            # accelerate, decelerate
+            segment.blocks = [
+                Block(a, m.t1, vi, m.p1, m.p2),
+                Block(-a, m.t2, m.vmax, m.p2, m.p3),
+            ]
+            next_segment.entry_velocity = vexit
+            i += 1
+
+    # concatenate all of the blocks
+    blocks = []
+    for segment in segments:
+        blocks.extend(segment.blocks)
+
+    # filter out zero-duration blocks and return
+    blocks = [b for b in blocks if b.t > EPS]
+    return Plan(blocks)
+
+
+def find_port():
+    for port in comports():
+        if VID_PID in port[2]:
+            return port[0]
+    return None
+
+class Device(object):
+    def __init__(self, **kwargs):
+        self.steps_per_unit = STEPS_PER_INCH
+        self.pen_up_position = PEN_UP_POSITION
+        self.pen_up_speed = PEN_UP_SPEED
+        self.pen_up_delay = PEN_UP_DELAY
+        self.pen_down_position = PEN_DOWN_POSITION
+        self.pen_down_speed = PEN_DOWN_SPEED
+        self.pen_down_delay = PEN_DOWN_DELAY
+        self.acceleration = ACCELERATION
+        self.max_velocity = MAX_VELOCITY
+        self.corner_factor = CORNER_FACTOR
+        self.jog_acceleration = JOG_ACCELERATION
+        self.jog_max_velocity = JOG_MAX_VELOCITY
+
+        for k, v in kwargs.items():
+            setattr(self, k, v)
+
+        self.error = (0, 0) # accumulated step error
+
+        port = find_port()
+        if port is None:
+            raise Exception('cannot find axidraw device')
+        self.serial = Serial(port, timeout=1)
+        self.configure()
+
+    def configure(self):
+        servo_min = 7500
+        servo_max = 28000
+        pen_up_position = self.pen_up_position / 100
+        pen_up_position = int(
+            servo_min + (servo_max - servo_min) * pen_up_position)
+        pen_down_position = self.pen_down_position / 100
+        pen_down_position = int(
+            servo_min + (servo_max - servo_min) * pen_down_position)
+        self.command('SC', 4, pen_up_position)
+        self.command('SC', 5, pen_down_position)
+        self.command('SC', 11, int(self.pen_up_speed * 5))
+        self.command('SC', 12, int(self.pen_down_speed * 5))
+
+    def close(self):
+        self.serial.close()
+
+    def make_planner(self, jog=False):
+        a = self.acceleration
+        vmax = self.max_velocity
+        cf = self.corner_factor
+        if jog:
+            a = self.jog_acceleration
+            vmax = self.jog_max_velocity
+        return Planner(a, vmax, cf)
+
+    def readline(self):
+        return self.serial.readline().decode('utf-8').strip()
+
+    def command(self, *args):
+        line = ','.join(map(str, args))
+        self.serial.write((line + '\r').encode('utf-8'))
+        return self.readline()
+
+    # higher level functions
+    def move(self, dx, dy):
+        self.run_path([(0, 0), (dx, dy)])
+
+    def goto(self, x, y, jog=True):
+        # TODO: jog if pen up
+        px, py = self.read_position()
+        self.run_path([(px, py), (x, y)], jog)
+
+    def home(self):
+        self.goto(0, 0, True)
+
+    def enable_motors(self):
+        m = MICROSTEPPING_MODE
+        return self.command('EM', m, m)
+
+    def disable_motors(self):
+        return self.command('EM', 0, 0)
+
+    def motor_status(self):
+        return self.command('QM')
+
+
+
+    def read_position(self):
+        response = self.command('QS')
+        self.readline()
+        a, b = map(int, response.split(','))
+        a /= self.steps_per_unit
+        b /= self.steps_per_unit
+        y = (a - b) / 2
+        x = y + b
+        return x, y
+
+    def stepper_move(self, duration, a, b):
+        return self.command('XM', duration, a, b)
+
+
+    def run_plan(self, plan):
+        step_ms = TIMESLICE_MS
+        step_s = step_ms / 1000
+        t = 0
+        while t < plan.t:
+            i1 = plan.instant(t)
+            i2 = plan.instant(t + step_s)
+            d = i2.p.sub(i1.p)
+            ex, ey = self.error
+            ex, sx = modf(d.x * self.steps_per_unit + ex)
+            ey, sy = modf(d.y * self.steps_per_unit + ey)
+            self.error = ex, ey
+            self.stepper_move(step_ms, int(sx), int(sy))
+            t += step_s
+        # self.wait()
+
+    def run_path(self, path, jog=False):
+        planner = self.make_planner(jog)
+        plan = planner.plan(path)
+        self.run_plan(plan)
+
+
+    # pen functions
+    def pen_up(self):
+        delta = abs(self.pen_up_position - self.pen_down_position)
+        duration = int(1000 * delta / self.pen_up_speed)
+        delay = max(0, duration + self.pen_up_delay)
+        return self.command('SP', 1, delay)
+
+    def pen_down(self):
+        delta = abs(self.pen_up_position - self.pen_down_position)
+        duration = int(1000 * delta / self.pen_down_speed)
+        delay = max(0, duration + self.pen_down_delay)
+        return self.command('SP', 0, delay)
+
+
+import os
+import sys
+import time
+import gpiozero   # pylint: disable=import-error
+from xmlrpc.server import SimpleXMLRPCServer
+import yaml
+
+
+sys.path.append(os.path.dirname(__file__))
+import axi
+
+class AxiDrawError(Exception):
+    """Custom exception for AxiDraw-related errors."""
+    pass
+
+
+class AxiDrawServer:
+
+    def __init__(self, x_pin, y_pin):
+        self.axi = None
+        self.limit_pin_x = x_pin
+        self.limit_pin_y = y_pin
+
+        self.limit_switch_x = gpiozero.Button(self.limit_pin_x, pull_up=False)
+        self.limit_switch_y = gpiozero.Button(self.limit_pin_y, pull_up=False)
+
+    def _check_connection(self):
+        if self.axi:
+            return True
+        raise AxiDrawError("AxiDraw not connected")
+
+    def _is_triggered(self, axis: str):
+        """
+        Check if limit switch is triggered for a given axis (active HIGH).
+        axis: "x" or "y"
+        """
+        if axis.lower() == "x":
+            state = self.limit_switch_x.is_pressed
+        elif axis.lower() == "y":
+            state = self.limit_switch_y.is_pressed
+        else:
+            raise ValueError("Invalid axis. Use 'x' or 'y'.")
+
+        print(f"[DEBUG] {axis.upper()} limit switch state: {state}")
+        return state
+
+
+    def connect(self, acceleration=100,
+                pen_up=60, pen_down=30,
+                speed_penup=150, speed_pendown=150):
+        try:
+            self.axi = axi.Device(
+                pen_up_position=pen_up,
+                pen_down_position=pen_down,
+                acceleration=acceleration,
+                pen_up_speed=speed_penup,
+                pen_down_speed=speed_pendown
+            )
+            return True, "Connected"
+        except Exception as error:
+            raise AxiDrawError(f"Unable to connect to AxiDraw: {error}")
+
+    def disconnect(self):
+        if not self.axi:
+            return True, "Already disconnected"
+        try:
+            self.axi.disable_motors()
+            self.axi.close()
+            self.axi = None
+            return True, "Disconnected"
+        except Exception as e:
+            return False, f"Error during disconnect: {str(e)}"
+
+    def set_pen_height(self, pen_up: int, pen_down: int):
+        self._check_connection()
+        self.axi.pen_up_position = pen_up
+        self.axi.pen_down_position = pen_down
+        if self.axi.configure():
+            return True, "Pen height adjusted"
+        return False, "Failed to adjust pen height"
+
+    def set_speed(self, acceleration: int, penup_speed: int, pendown_speed: int):
+        self._check_connection()
+        self.axi.pen_up_speed = penup_speed
+        self.axi.pen_down_speed = pendown_speed
+        self.axi.acceleration = acceleration
+        if self.axi.configure():
+            return True, "Speed adjusted"
+        return False, "Failed to set speed"
+
+    def tap(self, x, y, tap_time=0.2):
+        self._check_connection()
+        try:
+            self.axi.goto(x, y)
+            self.axi.pen_down()
+            time.sleep(tap_time)
+            self.axi.pen_up()
+            return True, "Tap succeeded"
+        except Exception as error:
+            return False, f"Tap failed: {error}"
+
+    def long_press(self, x, y, hold_time=2.0):
+        self._check_connection()
+        try:
+            self.axi.goto(x, y)
+            self.axi.pen_down()
+            time.sleep(hold_time)
+            self.axi.pen_up()
+            return True, "Long press succeeded"
+        except Exception as error:
+            return False, f"Long press failed: {error}"
+
+    def swipe(self, startx, starty, endx, endy, swipe_time=0.5):
+        self._check_connection()
+        try:
+            self.axi.goto(startx, starty)
+            self.axi.pen_down()
+            self.axi.goto(endx, endy)
+            # time.sleep(swipe_time)
+            self.axi.pen_up() # Need to check the swipe flow.
+            return True, "Swipe succeeded"
+        except Exception as error:
+            return False, f"Swipe failed: {error}"
+
+    def home(self):
+        self._check_connection()
+        try:
+            self.axi.goto(0, 0)
+            return True, "Homed to (0,0)"
+        except Exception as e:
+            return False, f"Home failed: {e}"
+
+    def home_with_switch(self, axis: str):
+        """Homing routine using X or Y axis limit switch."""
+        self._check_connection()
+        print(f"Starting {axis.upper()}-axis homing with switch...")
+
+        if axis.lower() == "x":
+            # Step 1: Coarse move
+            while not self._is_triggered("x"):
+                self.axi.move(-0.4, 0)
+                print("Moved X -0.4")
+                time.sleep(0.1)
+            print("X switch hit (coarse).")
+
+            # Step 2: Back off
+            self.axi.move(0.5, 0)
+            time.sleep(0.2)
+
+            # Step 3: Fine approach
+            while not self._is_triggered("x"):
+                self.axi.move(-0.1, 0)
+                print("Moved X -0.1")
+                time.sleep(0.05)
+            print("X precise home reached.")
+            return True, "X-axis homed"
+
+        elif axis.lower() == "y":
+            # Step 1: Coarse move
+            while not self._is_triggered("y"):
+                self.axi.move(0, -0.4)
+                print("Moved Y -0.4")
+                time.sleep(0.1)
+            print("Y switch hit (coarse).")
+
+            # Step 2: Back off
+            self.axi.move(0, 0.5)
+            time.sleep(0.2)
+
+            # Step 3: Fine approach
+            while not self._is_triggered("y"):
+                self.axi.move(0, -0.1)
+                print("Moved Y -0.1")
+                time.sleep(0.05)
+            print("Y precise home reached.")
+            return True, "Y-axis homed"
+
+        else:
+            return False, "Invalid axis: choose 'x' or 'y'"
+
+    def calibrate_with_switch(self, axis: str):
+        """calibrating using X or Y axis limit switch."""
+        self._check_connection()
+        print(f"Starting {axis.upper()}-axis calibrating with switch...")
+        count = 0
+
+        if axis.lower() == "x":
+            # Step 1: Coarse move
+            while not self._is_triggered("x"):
+                self.axi.move(-0.1, 0)
+                print("Moved X -0.1")
+                count = count - 0.1
+                time.sleep(0.1)
+            print("X switch hit (coarse).")
+
+            # Step 2: Back off
+            self.axi.move(0.2, 0)
+            count = count + 0.2
+            time.sleep(0.2)
+
+            # Step 3: Fine approach
+            while not self._is_triggered("x"):
+                self.axi.move(-0.025, 0)
+                print("Moved X -0.025")
+                count = count - 0.025
+                time.sleep(0.05)
+            print("X precise home reached.")
+            return count
+
+        elif axis.lower() == "y":
+            # Step 1: Coarse move
+            while not self._is_triggered("y"):
+                self.axi.move(0, -0.1)
+                print("Moved Y -0.1")
+                count = count - 0.1
+                time.sleep(0.1)
+            print("Y switch hit (coarse).")
+
+            # Step 2: Back off
+            self.axi.move(0, 0.2)
+            count = count + 0.2
+            time.sleep(0.2)
+
+            # Step 3: Fine approach
+            while not self._is_triggered("y"):
+                self.axi.move(0, -0.025)
+                print("Moved Y -0.025")
+                count = count - 0.025
+                time.sleep(0.05)
+            print("Y precise home reached.")
+            return count
+
+        else:
+            return False, "Invalid axis: choose 'x' or 'y'"
+
+    def home_with_limit_switch(self):
+        """
+        Homing routine using X or Y axis limit switch.
+        """
+        self._check_connection()
+        self.home_with_switch("x")
+        self.home_with_switch("y")
+
+    def calibrate_with_limit_switch(self):
+        """
+        Calibrating using X or Y axis limit switch.
+        """
+        self._check_connection()
+        x_pos = self.calibrate_with_switch("x")
+        y_pos = self.calibrate_with_switch("y")
+        return x_pos, y_pos
+        
+    def penup(self):
+        self._check_connection()
+        self.axi.pen_up()
+        return True, "Pen up"
+
+    def pendown(self):
+        self._check_connection()
+        self.axi.pen_down()
+        return True, "Pen down"
+
+    def get_current_position(self):
+        self._check_connection()
+        return True, self.axi.read_position()
+
+    def move(self, x, y):
+        self._check_connection()
+        self.axi.move(x, y)
+        return True, f"Moved by ({x}, {y})"
+
+
+if __name__ == "__main__":
+
+    try:
+        with open("/etc/rpi-axitouch/config.yaml") as config_file:
+            yaml_config: dict = yaml.safe_load(config_file)
+            config: dict = yaml_config.get("AxiDrawServer", {})
+    except FileNotFoundError:
+        print("Config file not found. Using defaults.")
+        config = {}
+
+    host = config['host']
+    port = config['port']
+    limit_pin_x = config["limit_pin_x"]
+    limit_pin_y = config["limit_pin_y"]
+    auto_home = config.get("auto_home", True)  # Default True to preserve existing behaviour
+
+    server = SimpleXMLRPCServer((host, port), allow_none=True)
+    axidraw = AxiDrawServer(limit_pin_x, limit_pin_y)
+    server.register_instance(axidraw)
+
+    print(f"AxiDraw Server started on {host}:{port}")
+
+    try:
+        axidraw.connect()
+        print("Axi connected")
+
+        if auto_home:
+            print("Auto-homing enabled — running homing sequence...")
+            axidraw.home_with_switch("y")
+            axidraw.home_with_switch("x")
+            print("Homing complete.")
+        else:
+            print("Auto-homing disabled — skipping homing sequence.")
+
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("Shutting down server...")
+    finally:
+        axidraw.disconnect()
+        print("AxiDraw disconnected.")
+

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "robotframework-parrot-touchcontroller"
-version = "1.0.1"
+version = "1.1.0"
 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.1.0}/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.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

{robotframework_parrot_touchcontroller-1.0.1 → robotframework_parrot_touchcontroller-1.1.0}/robotframework_parrot_touchcontroller.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 parrot/TouchController.py
 parrot/touch/adbtouch.py
 parrot/touch/axitouch.py
+parrot/touch/axitouchserial.py
 parrot/touch/base.py
 parrot/touch/dummy.py
 parrot/touch/usbhidtouch.py