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

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

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

@@ -40,6 +40,12 @@ 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.
@@ -66,6 +72,7 @@ class TouchController:
     |     height: 600
     |     start_pos: [0, 0]
     |     end_pos: [8.66, 5.12]
+    |     orientation: landscape
     |
     |   T3:
     |     type: ADBTouch

{robotframework_parrot_touchcontroller-1.1.0 → robotframework_parrot_touchcontroller-1.1.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.1.0 → robotframework_parrot_touchcontroller-1.1.2}/pyproject.toml

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

{robotframework_parrot_touchcontroller-1.1.0 → robotframework_parrot_touchcontroller-1.1.2}/robotframework_parrot_touchcontroller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-parrot-touchcontroller
-Version: 1.1.0
+Version: 1.1.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.1.0 → robotframework_parrot_touchcontroller-1.1.2}/robotframework_parrot_touchcontroller.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ 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

robotframework_parrot_touchcontroller-1.1.0/parrot/touch/axitouchserial.py

@@ -1,1147 +0,0 @@
-# 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.")
-