From e9b4d73084f13b2ac1439597ada7dee265c892e7 Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Tue, 10 Feb 2026 16:59:31 +0000
Subject: [PATCH 01/30] First implementation of interruptable jog moves.

This introduces a new move command, "jog", which is a relative move that may be interrupted. The idea is that a client may send repeated requests to invoke "jog" actions, and each action replaces the previous one. This should mean that a continuous stream of "jog" requests results in continuous motion of the stage.

Motion may be stopped by cancelling an ongoing `jog` action, or by waiting for the move to complete.

My rationale for implementing it this way is that we have a built in fail-safe, because the stage will automatically stop after the current `jog` move completes, unless it gets another request. Using a short move (e.g. 0.5s) means it should never overrun by more than that.
---
 .../things/stage/sangaboard.py                | 187 +++++++++++++++++-
 1 file changed, 185 insertions(+), 2 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 7429aea3..43edae8b 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import threading
+import time
+from collections.abc import Sequence
 from contextlib import contextmanager
 from copy import copy
+from queue import Queue
 from types import TracebackType
 from typing import Any, Iterator, Literal, Optional, Self
 
@@ -19,6 +22,32 @@ REQUIRED_VERSION = semver.Version.parse("1.0.0")
 RECOMMENDED_VERSION = semver.Version.parse("1.0.4")
 
 
+class JogCommand:
+    """A base class for jog operations."""
+
+    def __init__(self) -> None:
+        """Initialise a JogCommand."""
+        super().__init__()
+        self.received = threading.Event()
+        self.finished = threading.Event()
+
+
+class JogMoveCommand(JogCommand):
+    """A command to make a jog move."""
+
+    def __init__(self, displacement: Sequence[int]) -> None:
+        """Initialise a JogMoveCommand.
+
+        :param displacement: The displacement for the jog move, in hardware coordinates.
+        """
+        super().__init__()
+        self.displacement = displacement
+
+
+class JogStopCommand(JogCommand):
+    """A command to stop a jog move."""
+
+
 class SangaboardThing(BaseStage):
     """A Thing to manage a Sangaboard motor controller.
 
@@ -49,6 +78,11 @@ class SangaboardThing(BaseStage):
         self.sangaboard_kwargs = copy(kwargs)
         self.sangaboard_kwargs["port"] = port
         self._sangaboard_lock = threading.RLock()
+
+        self._jog_lock = threading.Lock()
+        self._jog_queue: Queue[JogCommand] = Queue[JogCommand](maxsize=1)
+        self._jog_thread: Optional[threading.Thread] = None
+
         super().__init__(thing_server_interface, **kwargs)
 
     def __enter__(self) -> Self:
@@ -118,6 +152,46 @@ class SangaboardThing(BaseStage):
                     f"{RECOMMENDED_VERSION}."
                 )
 
+    def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
+        """Start a relative move.
+
+        This starts the stage moving, but does not wait for the move to complete. It
+        sets ``self.moving`` to `True`: resetting it is the responsibility of the calling code.
+        """
+        with self.sangaboard() as sb:
+            self.moving = True
+            sb.move_rel(displacement)
+
+    def _hardware_stop(self) -> None:
+        """Stop any motion of the stage as soon as possible."""
+        with self.sangaboard() as sb:
+            sb.query("stop")
+            self.moving = False
+
+    def _move_duration(self, displacement: Sequence[int]) -> float:
+        """Calculate the expected duration of a move with the given displacement."""
+        max_displacement = max(abs(d) for d in displacement)
+        return max_displacement * 0.001  # This does not yet check the board's speed.
+
+    def _poll_moving(self) -> bool:
+        """Determine if the stage is still moving.
+
+        This also sets `self.moving` if the status has changed.
+
+        :return: whether the stage is still moving.
+        """
+        with self.sangaboard() as sb:
+            moving = sb.query("moving?") == "true"
+            if self.moving != moving:
+                self.moving = moving
+            return moving
+
+    def _poll_until_stopped(self) -> None:
+        """Poll the stage until it reports that it has stopped moving."""
+        with self.sangaboard():
+            while self._poll_moving():
+                lt.cancellable_sleep(0.1)
+
     def _hardware_move_relative(
         self,
         block_cancellation: bool = False,
@@ -125,20 +199,24 @@ class SangaboardThing(BaseStage):
     ) -> None:
         """Make a relative move in the coordinate system used by the sangaboard."""
         displacement = [kwargs.get(axis, 0) for axis in self.axis_names]
+        duration = self._move_duration(displacement)
         with self.sangaboard() as sb:
-            self.moving = True
             try:
                 sb.move_rel(displacement)
                 if block_cancellation:
                     sb.query("notify_on_stop")
                 else:
+                    if duration > 0.2:
+                        lt.cancellable_sleep(
+                            duration - 0.1
+                        )  # Avoid unnecessary polling
                     while sb.query("moving?") == "true":
                         lt.cancellable_sleep(0.1)
             except lt.exceptions.InvocationCancelledError as e:
                 # If the move has been cancelled, stop it but don't handle the exception.
                 # We need the exception to propagate in order to stop any calling tasks,
                 # and to mark the invocation as "cancelled" rather than stopped.
-                sb.query("stop")
+                self._hardware_stop()
                 raise e
             finally:
                 self.moving = False
@@ -198,3 +276,108 @@ class SangaboardThing(BaseStage):
                 sb.query(f"{led_command} {on_brightness}")
             else:
                 sb.query(f"{led_command} 0")
+
+    @lt.action
+    def jog(self, stop: bool = False, **kwargs: int) -> None:
+        r"""Make a relative move that may be interrupted by a future ``jog``\ .
+
+        This action makes a relative move. If another ``jog`` action is called while
+        a ``jog`` is already in progress, the first will be stopped and the second
+        will start immediately. This allows for responsive manual control of the
+        stage, for example with a joystick.
+
+        :param stop: if this is set to `True` the jog will be terminated.
+        :param \**kwargs: Keyword arguments should be axis names.
+        """
+        if stop:
+            self._send_jog_command(JogStopCommand(), wait=True, timeout=1)
+        else:
+            self._hardware_jog(**self._apply_axis_direction(kwargs))
+
+    def _hardware_jog(self, **kwargs: int) -> None:
+        r"""Make a relative move that may be interrupted by a future ``jog``\ .
+
+        This function uses hardware coordinates, ``jog`` is the public wrapper that
+        applies any neecessary transform and then calls this function. See the
+        docs for that function for more explanation.
+
+        See `_jog_loop` for an explanation of the mechanism.
+
+        :param \**kwargs: Keyword arguments should be axis names.
+        """
+        move = [kwargs.get(axis, 0) for axis in self.axis_names]
+        self._send_jog_command(
+            JogMoveCommand(move),
+            timeout=self._move_duration(move) + 1,
+        )
+
+    def _send_jog_command(
+        self, command: JogCommand, timeout: Optional[float] = None
+    ) -> None:
+        """Send a jog command to the background jog thread.
+
+        This function will start the background thread if it is not running.
+        This function acquires `_jog_lock` and uses the `_jog_send` event to signal
+        the thread to read the next command. As commands interrupt each other, this
+        function should never block for a long time.
+
+        :param command: the jog command to send.
+        :param timeout: how long to wait for the command to be completed, or `None`
+            to skip waiting.
+        """
+        with self._jog_lock:
+            # Make sure the queue exists.
+            # Check the background thread is running, and restart it if not.
+            if self._jog_thread is None or not self._jog_thread.is_alive():
+                self._jog_queue = Queue[JogCommand](maxsize=1)
+                self._jog_thread = threading.Thread(target=self._jog_loop)
+                self._jog_thread.start()
+            self._jog_queue.put(command)
+            command.received.wait(1)
+            if timeout is not None:
+                command.finished.wait(timeout)
+
+    def _jog_loop(self) -> None:
+        r"""Execute jog commands in a background thread.
+
+        This function is intended to be run in a background thread. It will look at
+        `self._jog_command` when the `self._jog_send` event is set, and signal that
+        the command is being processed with `self._jog_received`\ .
+
+        If no new command is received before the current command finishes, the thread
+        will terminate, and `self._jog_received` will be set again. This means that
+        it should be safe to
+        """
+        duration = 1  # How long to wait initially. This shouldn't ever need to be long.
+        # On subsequent loop iterations, we'll wait long enough that we expect the last
+        # move to have finished.
+        previous_command: Optional[JogCommand] = None
+        with (
+            self.sangaboard() as _sb
+        ):  # prevent others using the sangaboard while jogging.
+            while True:
+                try:
+                    command = self._jog_queue.get(timeout=duration)
+                except TimeoutError:
+                    if self._poll_moving():
+                        # If there's no new command, keep checking for new commands until
+                        # we stop.
+                        duration = 0.1
+                        continue
+                    # Once the stage is no longer moving, stop listening for commands.
+                    break
+                command.received.set()  # Acknowledge the command
+                if previous_command:
+                    previous_command.finished.set()  # Notify the last command it's superseded
+                if isinstance(command, JogMoveCommand):
+                    self._hardware_start_move_relative(command.displacement)
+                    duration = self._move_duration(command.displacement)
+                elif isinstance(command, JogStopCommand):
+                    self._hardware_stop()
+                    self._poll_until_stopped()
+                    duration = 0.1  # Next iteration, we will probably time out.
+                else:
+                    raise RuntimeError(f"Unknown jog command: {command}")
+            if previous_command:
+                # Notify the last command that it finished, because we stopped moving.
+                previous_command.finished.set()

From 3753341893779e717ab77b9b2d693b3b7885ae6b Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Tue, 10 Feb 2026 23:25:44 +0000
Subject: [PATCH 02/30] First working version of jog

I've fixed a few issues, used the right exception for queue timeouts, and added a __repr__ to jog commands for nicer debug output.

This now works - it's not flawlessly smooth, but it's pretty close. The limiting factor seems to be the repeat rate of the keypresses in javascript.
---
 .../things/stage/sangaboard.py                | 28 +++++++++++++++----
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 43edae8b..4ee506dc 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -7,7 +7,7 @@ import time
 from collections.abc import Sequence
 from contextlib import contextmanager
 from copy import copy
-from queue import Queue
+from queue import Queue, Empty
 from types import TracebackType
 from typing import Any, Iterator, Literal, Optional, Self
 
@@ -31,6 +31,10 @@ class JogCommand:
         self.received = threading.Event()
         self.finished = threading.Event()
 
+    def __repr__(self) -> str:
+        """Represent the command as a string."""
+        return f"<{self.__class__.__name__}>"
+
 
 class JogMoveCommand(JogCommand):
     """A command to make a jog move."""
@@ -43,6 +47,10 @@ class JogMoveCommand(JogCommand):
         super().__init__()
         self.displacement = displacement
 
+    def __repr__(self) -> str:
+        """Represent the command as a string."""
+        return f"<{self.__class__.__name__} {self.displacement}>"
+
 
 class JogStopCommand(JogCommand):
     """A command to stop a jog move."""
@@ -290,7 +298,7 @@ class SangaboardThing(BaseStage):
         :param \**kwargs: Keyword arguments should be axis names.
         """
         if stop:
-            self._send_jog_command(JogStopCommand(), wait=True, timeout=1)
+            self._send_jog_command(JogStopCommand(), timeout=1)
         else:
             self._hardware_jog(**self._apply_axis_direction(kwargs))
 
@@ -329,13 +337,16 @@ class SangaboardThing(BaseStage):
             # Make sure the queue exists.
             # Check the background thread is running, and restart it if not.
             if self._jog_thread is None or not self._jog_thread.is_alive():
+                self.logger.info("Starting background thread for jog commands")
                 self._jog_queue = Queue[JogCommand](maxsize=1)
                 self._jog_thread = threading.Thread(target=self._jog_loop)
                 self._jog_thread.start()
             self._jog_queue.put(command)
             command.received.wait(1)
-            if timeout is not None:
-                command.finished.wait(timeout)
+        # The final wait happens after releasing the lock: this allows jog moves to
+        # be interrupted.
+        if timeout is not None:
+            command.finished.wait(timeout)
 
     def _jog_loop(self) -> None:
         r"""Execute jog commands in a background thread.
@@ -357,24 +368,29 @@ class SangaboardThing(BaseStage):
         ):  # prevent others using the sangaboard while jogging.
             while True:
                 try:
+                    waitstart = time.time()
                     command = self._jog_queue.get(timeout=duration)
-                except TimeoutError:
+                    self.logger.info(f"Got command {command} after {time.time() - waitstart}")
+                except Empty:
+                    self.logger.info(f"Timed out waiting for a command, waited {duration}.")
                     if self._poll_moving():
                         # If there's no new command, keep checking for new commands until
                         # we stop.
+                        self.logger.info(f"Still moving, will wait for the stage to stop.")
                         duration = 0.1
                         continue
                     # Once the stage is no longer moving, stop listening for commands.
+                    self.logger.info(f"Stage has stopped, terminating.")
                     break
                 command.received.set()  # Acknowledge the command
                 if previous_command:
                     previous_command.finished.set()  # Notify the last command it's superseded
+                previous_command = command
                 if isinstance(command, JogMoveCommand):
                     self._hardware_start_move_relative(command.displacement)
                     duration = self._move_duration(command.displacement)
                 elif isinstance(command, JogStopCommand):
                     self._hardware_stop()
-                    self._poll_until_stopped()
                     duration = 0.1  # Next iteration, we will probably time out.
                 else:
                     raise RuntimeError(f"Unknown jog command: {command}")

From d09a5a8ee2343e08461cb4e8e6bae8991ed52d0e Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Tue, 10 Feb 2026 23:38:20 +0000
Subject: [PATCH 03/30] Use jog action for arrow keys.

This now makes the arrow keys work more or less continuously, and stop responsively.

It could do with optimisation so the key rep rate is lower, but the initial wait is shorter. That probably entails adding our own timeout.
---
 webapp/src/App.vue                                        | 8 ++++++++
 .../controlComponents/positionControl.vue                 | 6 ++++--
 webapp/vite.config.mjs                                    | 4 +---
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index 673d4708..5aed7071 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -143,6 +143,7 @@ export default {
       ["up", "down", "left", "right"],
       (event) => {
         delete this.arrowKeysDown[event.keyCode]; //Remove key from array
+        this.invokeAction("stage", "jog", { stop: true });
       },
       "keyup",
     );
@@ -158,6 +159,13 @@ export default {
     Mousetrap.bind("pagedown", () => {
       eventBus.emit("globalMoveStepEvent", { x: 0, y: 0, z: -1 });
     });
+    Mousetrap.bind(
+      ["pageup", "pagedown"],
+      () => {
+        this.invokeAction("stage", "jog", { stop: true });
+      },
+      "keyup",
+    );
     this.keyboardManual.push({
       shortcut: "pgup / pgdn",
       description: "Move the microscope focus",
diff --git a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
index 7c14416e..dc56e226 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
@@ -76,6 +76,7 @@ export default {
     return {
       setPosition: null,
       moveLock: false,
+      jogging: false,
     };
   },
 
@@ -94,6 +95,7 @@ export default {
     eventBus.on("globalMoveInImageCoordinatesEvent", this.onMoveImage);
     // A global signal listener to perform a move in multiples of a step size
     eventBus.on("globalMoveStepEvent", this.onMoveStep);
+
     // Update the current position in text boxes
     await this.updatePosition();
   },
@@ -122,8 +124,7 @@ export default {
       const x = x_steps * navigationStepSize.x * (navigationInvert.x ? -1 : 1);
       const y = y_steps * navigationStepSize.y * (navigationInvert.y ? -1 : 1);
       const z = z_steps * navigationStepSize.z * (navigationInvert.z ? -1 : 1);
-      const movePayload = { x, y, z, absolute: false };
-      eventBus.emit("globalMoveEvent", movePayload);
+      this.invokeAction("stage", "jog", { x: x, y: y, z: z });
     },
 
     async move(payload) {
@@ -131,6 +132,7 @@ export default {
       // Move the stage, by updating the controls and starting a move task
       // This is equivalent to clicking the "move" button.
       if (this.moveLock) return; // Discard move requests if we're already moving
+      if (this.jogging) return; // Discard move requests if a jog is in progress
       // NB moveLock is just  boolean flag - it's not as safe as a "proper" lock.
       this.moveLock = true; // This will also be set by the task submitter, but
       // setting it here avoids multiple moves being requested simultaneously.
diff --git a/webapp/vite.config.mjs b/webapp/vite.config.mjs
index 2f1adf70..bdc2bc35 100644
--- a/webapp/vite.config.mjs
+++ b/webapp/vite.config.mjs
@@ -9,9 +9,7 @@ import vue from "@vitejs/plugin-vue";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [
-    vue(),
-  ],
+  plugins: [vue()],
 
   build: {
     // Output directory for production builds

From 04e7fa30bda60a7306b903bd0df0a0ce6ceeff08 Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Tue, 10 Feb 2026 23:38:29 +0000
Subject: [PATCH 04/30] Format fixes

---
 .../things/stage/sangaboard.py                      | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 4ee506dc..a6313d4f 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -7,7 +7,7 @@ import time
 from collections.abc import Sequence
 from contextlib import contextmanager
 from copy import copy
-from queue import Queue, Empty
+from queue import Empty, Queue
 from types import TracebackType
 from typing import Any, Iterator, Literal, Optional, Self
 
@@ -370,17 +370,20 @@ class SangaboardThing(BaseStage):
                 try:
                     waitstart = time.time()
                     command = self._jog_queue.get(timeout=duration)
-                    self.logger.info(f"Got command {command} after {time.time() - waitstart}")
+                    self.logger.info(
+                        f"Got command {command} after {time.time() - waitstart}"
+                    )
                 except Empty:
-                    self.logger.info(f"Timed out waiting for a command, waited {duration}.")
+                    self.logger.info(
+                        f"Timed out waiting for a command, waited {duration}."
+                    )
                     if self._poll_moving():
                         # If there's no new command, keep checking for new commands until
                         # we stop.
-                        self.logger.info(f"Still moving, will wait for the stage to stop.")
                         duration = 0.1
                         continue
                     # Once the stage is no longer moving, stop listening for commands.
-                    self.logger.info(f"Stage has stopped, terminating.")
+                    self.logger.info("Stage has stopped, terminating jog thread.")
                     break
                 command.received.set()  # Acknowledge the command
                 if previous_command:

From 4d445396b2e58370ecf8a8241907a7b739748467 Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Wed, 11 Feb 2026 00:11:03 +0000
Subject: [PATCH 05/30] Update position property during and after jog

---
 src/openflexure_microscope_server/things/stage/sangaboard.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index a6313d4f..dfacbce8 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -397,6 +397,8 @@ class SangaboardThing(BaseStage):
                     duration = 0.1  # Next iteration, we will probably time out.
                 else:
                     raise RuntimeError(f"Unknown jog command: {command}")
+                self._update_position()
             if previous_command:
                 # Notify the last command that it finished, because we stopped moving.
                 previous_command.finished.set()
+            self._update_position()

From abda60adf6d76531f62e4ae203e721581e47a993 Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Wed, 11 Feb 2026 00:21:40 +0000
Subject: [PATCH 06/30] Prevent accidental queueing of jog commands

---
 .../things/stage/sangaboard.py                      | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index dfacbce8..0b5d42bc 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -333,7 +333,12 @@ class SangaboardThing(BaseStage):
         :param timeout: how long to wait for the command to be completed, or `None`
             to skip waiting.
         """
-        with self._jog_lock:
+        if not self._jog_lock.acquire(timeout=0.1):
+            self.logger.warning(
+                "Could not send a jog message, this indicates a lock error."
+            )
+            return
+        try:
             # Make sure the queue exists.
             # Check the background thread is running, and restart it if not.
             if self._jog_thread is None or not self._jog_thread.is_alive():
@@ -343,6 +348,8 @@ class SangaboardThing(BaseStage):
                 self._jog_thread.start()
             self._jog_queue.put(command)
             command.received.wait(1)
+        finally:
+            self._jog_lock.release()
         # The final wait happens after releasing the lock: this allows jog moves to
         # be interrupted.
         if timeout is not None:
@@ -397,8 +404,8 @@ class SangaboardThing(BaseStage):
                     duration = 0.1  # Next iteration, we will probably time out.
                 else:
                     raise RuntimeError(f"Unknown jog command: {command}")
-                self._update_position()
+                self.update_position()
             if previous_command:
                 # Notify the last command that it finished, because we stopped moving.
                 previous_command.finished.set()
-            self._update_position()
+            self.update_position()

From 9ed850cc68a6d916bbabb5db16501e5ceee4154e Mon Sep 17 00:00:00 2001
From: Richard Bowman <richard.bowman@cantab.net>
Date: Wed, 11 Feb 2026 00:24:40 +0000
Subject: [PATCH 07/30] Switch move buttons to use jog

This implements a nicer version of jogging, with a defined interval of 1/3 second. This can be tuned depending on what we think makes sense.

It might be good to re-use this for handling keypresses.
---
 .../things/stage/sangaboard.py                |  4 +-
 .../controlComponents/positionControl.vue     |  1 -
 .../controlComponents/stageControlButtons.vue | 67 ++++++++++++++++---
 3 files changed, 60 insertions(+), 12 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 0b5d42bc..138c17fa 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -366,7 +366,9 @@ class SangaboardThing(BaseStage):
         will terminate, and `self._jog_received` will be set again. This means that
         it should be safe to
         """
-        duration = 1  # How long to wait initially. This shouldn't ever need to be long.
+        duration = (
+            1.0  # How long to wait initially. This shouldn't ever need to be long.
+        )
         # On subsequent loop iterations, we'll wait long enough that we expect the last
         # move to have finished.
         previous_command: Optional[JogCommand] = None
diff --git a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
index dc56e226..4ad060ae 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
@@ -118,7 +118,6 @@ export default {
     },
 
     onMoveStep(payload) {
-      const { x: x_steps, y: y_steps, z: z_steps } = payload;
       const navigationStepSize = this.$store.state.navigationStepSize;
       const navigationInvert = this.$store.state.navigationInvert;
       const x = x_steps * navigationStepSize.x * (navigationInvert.x ? -1 : 1);
diff --git a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
index 775ce234..f88b9524 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
@@ -1,26 +1,52 @@
 <template>
   <div class="uk-flex uk-flex-center uk-flex-middle uk-margin">
     <div class="dpad-grid">
-      <button id="up-button" class="uk-button uk-button-primary dpad-btn" @click="move(0, 1, 0)">
+      <button
+        id="up-button"
+        class="uk-button uk-button-primary dpad-btn"
+        @mousedown="jog(0, 1, 0)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
+      >
         <span class="material-symbols-outlined sync-icon"> arrow_upward </span>
       </button>
 
-      <button id="left-button" class="uk-button uk-button-primary dpad-btn" @click="move(-1, 0, 0)">
+      <button
+        id="left-button"
+        class="uk-button uk-button-primary dpad-btn"
+        @mousedown="jog(-1, 0, 0)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
+      >
         <span class="material-symbols-outlined sync-icon"> arrow_back </span>
       </button>
 
-      <button id="right-button" class="uk-button uk-button-primary dpad-btn" @click="move(1, 0, 0)">
+      <button
+        id="right-button"
+        class="uk-button uk-button-primary dpad-btn"
+        @mousedown="jog(1, 0, 0)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
+      >
         <span class="material-symbols-outlined sync-icon"> arrow_forward </span>
       </button>
 
-      <button id="down-button" class="uk-button uk-button-primary dpad-btn" @click="move(0, -1, 0)">
+      <button
+        id="down-button"
+        class="uk-button uk-button-primary dpad-btn"
+        @mousedown="jog(0, -1, 0)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
+      >
         <span class="material-symbols-outlined sync-icon"> arrow_downward </span>
       </button>
 
       <button
         id="focus-out-button"
         class="uk-button uk-button-primary dpad-btn"
-        @click="move(0, 0, -1)"
+        @mousedown="jog(0, 0, -1)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> remove </span>
       </button>
@@ -28,7 +54,9 @@
       <button
         id="focus-in-button"
         class="uk-button uk-button-primary dpad-btn"
-        @click="move(0, 0, 1)"
+        @mousedown="jog(0, 0, 1)"
+        @mouseup="jogStop()"
+        @mouseOut="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> add </span>
       </button>
@@ -37,13 +65,32 @@
 </template>
 
 <script>
-import { eventBus } from "../../../eventBus.js";
-
 export default {
   name: "StageControlButtons",
+  data: () => ({
+    jogIntervalId: null,
+    jogDistance: 600,
+    jogTime: 300,
+  }),
   methods: {
-    move(x, y, z) {
-      eventBus.emit("globalMoveStepEvent", { x, y, z, absolute: false });
+    jog(x, y, z) {
+      if (this.jogIntervalId) {
+        clearInterval(this.jogIntervalId);
+      }
+      let invokeJog = () =>
+        this.invokeAction("stage", "jog", {
+          x: x * this.jogDistance,
+          y: y * this.jogDistance,
+          z: z * this.jogDistance,
+        });
+      invokeJog();
+      this.jogIntervalId = setInterval(invokeJog, this.jogTime);
+    },
+    jogStop() {
+      if (this.jogIntervalId) {
+        clearInterval(this.jogIntervalId);
+      }
+      this.invokeAction("stage", "jog", { stop: true });
     },
   },
 };

From 5af8ad5192586292626e59e97cb8b688646938fb Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Thu, 12 Feb 2026 20:26:15 +0000
Subject: [PATCH 08/30] Split jog dequing from calling commands

---
 .../things/stage/sangaboard.py                | 90 +++++++++----------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 138c17fa..feaa6725 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
+import queue
 import threading
-import time
 from collections.abc import Sequence
 from contextlib import contextmanager
 from copy import copy
-from queue import Empty, Queue
 from types import TracebackType
 from typing import Any, Iterator, Literal, Optional, Self
 
@@ -88,7 +87,7 @@ class SangaboardThing(BaseStage):
         self._sangaboard_lock = threading.RLock()
 
         self._jog_lock = threading.Lock()
-        self._jog_queue: Queue[JogCommand] = Queue[JogCommand](maxsize=1)
+        self._jog_queue: queue.Queue[JogCommand] = queue.Queue[JogCommand](maxsize=1)
         self._jog_thread: Optional[threading.Thread] = None
 
         super().__init__(thing_server_interface, **kwargs)
@@ -176,7 +175,7 @@ class SangaboardThing(BaseStage):
             sb.query("stop")
             self.moving = False
 
-    def _move_duration(self, displacement: Sequence[int]) -> float:
+    def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
         """Calculate the expected duration of a move with the given displacement."""
         max_displacement = max(abs(d) for d in displacement)
         return max_displacement * 0.001  # This does not yet check the board's speed.
@@ -207,7 +206,7 @@ class SangaboardThing(BaseStage):
     ) -> None:
         """Make a relative move in the coordinate system used by the sangaboard."""
         displacement = [kwargs.get(axis, 0) for axis in self.axis_names]
-        duration = self._move_duration(displacement)
+        duration = self._estimate_move_duration(displacement)
         with self.sangaboard() as sb:
             try:
                 sb.move_rel(displacement)
@@ -316,7 +315,7 @@ class SangaboardThing(BaseStage):
         move = [kwargs.get(axis, 0) for axis in self.axis_names]
         self._send_jog_command(
             JogMoveCommand(move),
-            timeout=self._move_duration(move) + 1,
+            timeout=self._estimate_move_duration(move) + 1,
         )
 
     def _send_jog_command(
@@ -343,10 +342,13 @@ class SangaboardThing(BaseStage):
             # Check the background thread is running, and restart it if not.
             if self._jog_thread is None or not self._jog_thread.is_alive():
                 self.logger.info("Starting background thread for jog commands")
-                self._jog_queue = Queue[JogCommand](maxsize=1)
-                self._jog_thread = threading.Thread(target=self._jog_loop)
+                self._jog_queue = queue.Queue[JogCommand](maxsize=1)
+                self._jog_thread = threading.Thread(
+                    target=self._jog_loop, args=(command,)
+                )
                 self._jog_thread.start()
-            self._jog_queue.put(command)
+            else:
+                self._jog_queue.put(command)
             command.received.wait(1)
         finally:
             self._jog_lock.release()
@@ -355,7 +357,7 @@ class SangaboardThing(BaseStage):
         if timeout is not None:
             command.finished.wait(timeout)
 
-    def _jog_loop(self) -> None:
+    def _jog_loop(self, first_command: JogCommand) -> None:
         r"""Execute jog commands in a background thread.
 
         This function is intended to be run in a background thread. It will look at
@@ -366,48 +368,46 @@ class SangaboardThing(BaseStage):
         will terminate, and `self._jog_received` will be set again. This means that
         it should be safe to
         """
-        duration = (
-            1.0  # How long to wait initially. This shouldn't ever need to be long.
-        )
-        # On subsequent loop iterations, we'll wait long enough that we expect the last
-        # move to have finished.
+        # Timeout for checking queue
+        timeout = 0.1
         previous_command: Optional[JogCommand] = None
-        with (
-            self.sangaboard() as _sb
-        ):  # prevent others using the sangaboard while jogging.
-            while True:
-                try:
-                    waitstart = time.time()
-                    command = self._jog_queue.get(timeout=duration)
-                    self.logger.info(
-                        f"Got command {command} after {time.time() - waitstart}"
-                    )
-                except Empty:
-                    self.logger.info(
-                        f"Timed out waiting for a command, waited {duration}."
-                    )
-                    if self._poll_moving():
-                        # If there's no new command, keep checking for new commands until
-                        # we stop.
-                        duration = 0.1
-                        continue
-                    # Once the stage is no longer moving, stop listening for commands.
-                    self.logger.info("Stage has stopped, terminating jog thread.")
-                    break
-                command.received.set()  # Acknowledge the command
+        command: Optional[JogCommand] = first_command
+
+        # prevent others using the sangaboard while jogging.
+        with self.sangaboard() as _sb:
+            while command is not None:
+                # Acknowledge the command
+                command.received.set()
                 if previous_command:
-                    previous_command.finished.set()  # Notify the last command it's superseded
+                    # Notify the last command it's superseded
+                    previous_command.finished.set()
                 previous_command = command
                 if isinstance(command, JogMoveCommand):
                     self._hardware_start_move_relative(command.displacement)
-                    duration = self._move_duration(command.displacement)
+                    timeout = self._estimate_move_duration(command.displacement)
                 elif isinstance(command, JogStopCommand):
                     self._hardware_stop()
-                    duration = 0.1  # Next iteration, we will probably time out.
+                    # Next iteration, we will probably time out.
+                    timeout = 0.1
                 else:
                     raise RuntimeError(f"Unknown jog command: {command}")
                 self.update_position()
-            if previous_command:
-                # Notify the last command that it finished, because we stopped moving.
-                previous_command.finished.set()
-            self.update_position()
+                command = self._get_from_jog_queue(timeout)
+
+    def _get_from_jog_queue(self, timeout: int) -> Optional[JogCommand]:
+        """Get the next JogCommand from the jog queue.
+
+        :param timeout: The estimtated time the move will take for the queue timeout.
+        :return: The jog command or None if the stage stops before a command is
+            received.
+        """
+        while True:
+            try:
+                return self._jog_queue.get(timeout=timeout)
+            except queue.Empty:
+                if not self._poll_moving():
+                    # The stage is no longer moving, return None
+                    return None
+            # If we reached here then the stage is still moving shorten timeout and
+            # check again.
+            timeout = 0.1

From 2f205a35e9f736e1d9420e26cd33ed93e6fa9378 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Thu, 12 Feb 2026 20:31:33 +0000
Subject: [PATCH 09/30] Fix docstrings

---
 .../things/stage/sangaboard.py                | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index feaa6725..8e3ae14d 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -163,7 +163,7 @@ class SangaboardThing(BaseStage):
         """Start a relative move.
 
         This starts the stage moving, but does not wait for the move to complete. It
-        sets ``self.moving`` to `True`: resetting it is the responsibility of the calling code.
+        sets ``self.moving`` to ``True``: resetting it is the responsibility of the calling code.
         """
         with self.sangaboard() as sb:
             self.moving = True
@@ -183,7 +183,7 @@ class SangaboardThing(BaseStage):
     def _poll_moving(self) -> bool:
         """Determine if the stage is still moving.
 
-        This also sets `self.moving` if the status has changed.
+        This also sets ``moving`` if the status has changed.
 
         :return: whether the stage is still moving.
         """
@@ -286,15 +286,15 @@ class SangaboardThing(BaseStage):
 
     @lt.action
     def jog(self, stop: bool = False, **kwargs: int) -> None:
-        r"""Make a relative move that may be interrupted by a future ``jog``\ .
+        """Make a relative move that may be interrupted by a future ``jog``.
 
         This action makes a relative move. If another ``jog`` action is called while
         a ``jog`` is already in progress, the first will be stopped and the second
         will start immediately. This allows for responsive manual control of the
         stage, for example with a joystick.
 
-        :param stop: if this is set to `True` the jog will be terminated.
-        :param \**kwargs: Keyword arguments should be axis names.
+        :param stop: if this is set to ``True`` the jog will be terminated.
+        :param kwargs: Keyword arguments should be axis names.
         """
         if stop:
             self._send_jog_command(JogStopCommand(), timeout=1)
@@ -302,7 +302,7 @@ class SangaboardThing(BaseStage):
             self._hardware_jog(**self._apply_axis_direction(kwargs))
 
     def _hardware_jog(self, **kwargs: int) -> None:
-        r"""Make a relative move that may be interrupted by a future ``jog``\ .
+        """Make a relative move that may be interrupted by a future ``jog``.
 
         This function uses hardware coordinates, ``jog`` is the public wrapper that
         applies any neecessary transform and then calls this function. See the
@@ -310,7 +310,7 @@ class SangaboardThing(BaseStage):
 
         See `_jog_loop` for an explanation of the mechanism.
 
-        :param \**kwargs: Keyword arguments should be axis names.
+        :param kwargs: Keyword arguments should be axis names.
         """
         move = [kwargs.get(axis, 0) for axis in self.axis_names]
         self._send_jog_command(
@@ -324,12 +324,12 @@ class SangaboardThing(BaseStage):
         """Send a jog command to the background jog thread.
 
         This function will start the background thread if it is not running.
-        This function acquires `_jog_lock` and uses the `_jog_send` event to signal
+        This function acquires ``_jog_lock`` and uses the ``_jog_send`` event to signal
         the thread to read the next command. As commands interrupt each other, this
         function should never block for a long time.
 
         :param command: the jog command to send.
-        :param timeout: how long to wait for the command to be completed, or `None`
+        :param timeout: how long to wait for the command to be completed, or ``None``
             to skip waiting.
         """
         if not self._jog_lock.acquire(timeout=0.1):
@@ -358,14 +358,14 @@ class SangaboardThing(BaseStage):
             command.finished.wait(timeout)
 
     def _jog_loop(self, first_command: JogCommand) -> None:
-        r"""Execute jog commands in a background thread.
+        """Execute jog commands in a background thread.
 
         This function is intended to be run in a background thread. It will look at
-        `self._jog_command` when the `self._jog_send` event is set, and signal that
-        the command is being processed with `self._jog_received`\ .
+        ``self._jog_command`` when the ``self._jog_send`` event is set, and signal that
+        the command is being processed with ``self._jog_received``.
 
         If no new command is received before the current command finishes, the thread
-        will terminate, and `self._jog_received` will be set again. This means that
+        will terminate, and ``self._jog_received`` will be set again. This means that
         it should be safe to
         """
         # Timeout for checking queue

From 70dd7bd99420ea1ca0ee4668a911e5c69562188e Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Thu, 12 Feb 2026 20:57:04 +0000
Subject: [PATCH 10/30] Generalise jog

---
 .../things/stage/__init__.py                  | 208 ++++++++++++++-
 .../things/stage/sangaboard.py                | 238 ++----------------
 2 files changed, 234 insertions(+), 212 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index fd495186..c6f2fb78 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -11,8 +11,10 @@ As the object will be used as a context manager create the hardware connection i
 
 from __future__ import annotations
 
+import queue
+import threading
 from collections.abc import Mapping, Sequence
-from typing import Any, Literal, overload
+from typing import Any, Literal, Optional, overload
 
 import labthings_fastapi as lt
 
@@ -30,6 +32,40 @@ class RedefinedBaseMovementError(RuntimeError):
     """
 
 
+class JogCommand:
+    """A base class for jog operations."""
+
+    def __init__(self) -> None:
+        """Initialise a JogCommand."""
+        super().__init__()
+        self.received = threading.Event()
+        self.finished = threading.Event()
+
+    def __repr__(self) -> str:
+        """Represent the command as a string."""
+        return f"<{self.__class__.__name__}>"
+
+
+class JogMoveCommand(JogCommand):
+    """A command to make a jog move."""
+
+    def __init__(self, displacement: Sequence[int]) -> None:
+        """Initialise a JogMoveCommand.
+
+        :param displacement: The displacement for the jog move, in hardware coordinates.
+        """
+        super().__init__()
+        self.displacement = displacement
+
+    def __repr__(self) -> str:
+        """Represent the command as a string."""
+        return f"<{self.__class__.__name__} {self.displacement}>"
+
+
+class JogStopCommand(JogCommand):
+    """A command to stop a jog move."""
+
+
 class BaseStage(lt.Thing):
     """A base stage class for OpenFlexure translation stages.
 
@@ -55,6 +91,10 @@ class BaseStage(lt.Thing):
             that all code in the child class uses the hardware reference frame.
         """
         super().__init__(thing_server_interface)
+        self._hardware_lock = threading.RLock()
+        self._jog_lock = threading.Lock()
+        self._jog_queue: queue.Queue[JogCommand] = queue.Queue[JogCommand](maxsize=1)
+        self._jog_thread: Optional[threading.Thread] = None
         self._hardware_position = dict.fromkeys(self._axis_names, 0)
 
         # This must be the last thing the function does in case it is caught in a try.
@@ -87,6 +127,12 @@ class BaseStage(lt.Thing):
     )
     """Used to convert coordinates between the program frame and the hardware frame."""
 
+    def update_position(self) -> None:
+        """Read position from the stage and set the corresponding property."""
+        raise NotImplementedError(
+            "StageThings must define their own update_position method"
+        )
+
     @overload
     def _apply_axis_direction(self, position: list[int] | tuple[int]) -> list[int]: ...
 
@@ -180,6 +226,166 @@ class BaseStage(lt.Thing):
             "StageThings must define their own move_absolute method"
         )
 
+    def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
+        """Start a relative move.
+
+        This starts the stage moving, but does not wait for the move to complete. It
+        sets ``self.moving`` to ``True``: resetting it is the responsibility of the
+        calling code.
+        """
+        raise NotImplementedError(
+            "StageThings must define their own hardware_start_move_relative method"
+        )
+
+    def _hardware_stop(self) -> None:
+        raise NotImplementedError(
+            "StageThings must define their own _hardware_stop method"
+        )
+
+    def _poll_moving(self) -> bool:
+        """Determine if the stage is still moving.
+
+        This also sets ``moving`` if the status has changed.
+
+        :return: whether the stage is still moving.
+        """
+        raise NotImplementedError(
+            "StageThings must define their own _poll_moving method"
+        )
+
+    def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
+        """Calculate the expected duration of a move with the given displacement."""
+        max_displacement = max(abs(d) for d in displacement)
+        return max_displacement * 0.001  # This does not yet check the board's speed.
+
+    @lt.action
+    def jog(self, stop: bool = False, **kwargs: int) -> None:
+        """Make a relative move that may be interrupted by a future ``jog``.
+
+        This action makes a relative move. If another ``jog`` action is called while
+        a ``jog`` is already in progress, the first will be stopped and the second
+        will start immediately. This allows for responsive manual control of the
+        stage, for example with a joystick.
+
+        :param stop: if this is set to ``True`` the jog will be terminated.
+        :param kwargs: Keyword arguments should be axis names.
+        """
+        if stop:
+            self._send_jog_command(JogStopCommand(), timeout=1)
+        else:
+            self._hardware_jog(**self._apply_axis_direction(kwargs))
+
+    def _hardware_jog(self, **kwargs: int) -> None:
+        """Make a relative move that may be interrupted by a future ``jog``.
+
+        This function uses hardware coordinates, ``jog`` is the public wrapper that
+        applies any neecessary transform and then calls this function. See the
+        docs for that function for more explanation.
+
+        See `_jog_loop` for an explanation of the mechanism.
+
+        :param kwargs: Keyword arguments should be axis names.
+        """
+        move = [kwargs.get(axis, 0) for axis in self.axis_names]
+        self._send_jog_command(
+            JogMoveCommand(move),
+            timeout=self._estimate_move_duration(move) + 1,
+        )
+
+    def _send_jog_command(
+        self, command: JogCommand, timeout: Optional[float] = None
+    ) -> None:
+        """Send a jog command to the background jog thread.
+
+        This function will start the background thread if it is not running.
+        This function acquires ``_jog_lock`` and uses the ``_jog_send`` event to signal
+        the thread to read the next command. As commands interrupt each other, this
+        function should never block for a long time.
+
+        :param command: the jog command to send.
+        :param timeout: how long to wait for the command to be completed, or ``None``
+            to skip waiting.
+        """
+        if not self._jog_lock.acquire(timeout=0.1):
+            self.logger.warning(
+                "Could not send a jog message, this indicates a lock error."
+            )
+            return
+        try:
+            # Make sure the queue exists.
+            # Check the background thread is running, and restart it if not.
+            if self._jog_thread is None or not self._jog_thread.is_alive():
+                self.logger.info("Starting background thread for jog commands")
+                self._jog_queue = queue.Queue[JogCommand](maxsize=1)
+                self._jog_thread = threading.Thread(
+                    target=self._jog_loop, args=(command,)
+                )
+                self._jog_thread.start()
+            else:
+                self._jog_queue.put(command)
+            command.received.wait(1)
+        finally:
+            self._jog_lock.release()
+        # The final wait happens after releasing the lock: this allows jog moves to
+        # be interrupted.
+        if timeout is not None:
+            command.finished.wait(timeout)
+
+    def _jog_loop(self, first_command: JogCommand) -> None:
+        """Execute jog commands in a background thread.
+
+        This function is intended to be run in a background thread. It will look at
+        ``self._jog_command`` when the ``self._jog_send`` event is set, and signal that
+        the command is being processed with ``self._jog_received``.
+
+        If no new command is received before the current command finishes, the thread
+        will terminate, and ``self._jog_received`` will be set again. This means that
+        it should be safe to
+        """
+        # Timeout for checking queue
+        timeout = 0.1
+        previous_command: Optional[JogCommand] = None
+        command: Optional[JogCommand] = first_command
+
+        # prevent others using the stage while jogging.
+        with self._hardware_lock:
+            while command is not None:
+                # Acknowledge the command
+                command.received.set()
+                if previous_command:
+                    # Notify the last command it's superseded
+                    previous_command.finished.set()
+                previous_command = command
+                if isinstance(command, JogMoveCommand):
+                    self._hardware_start_move_relative(command.displacement)
+                    timeout = self._estimate_move_duration(command.displacement)
+                elif isinstance(command, JogStopCommand):
+                    self._hardware_stop()
+                    # Next iteration, we will probably time out.
+                    timeout = 0.1
+                else:
+                    raise RuntimeError(f"Unknown jog command: {command}")
+                self.update_position()
+                command = self._get_from_jog_queue(timeout)
+
+    def _get_from_jog_queue(self, timeout: float) -> Optional[JogCommand]:
+        """Get the next JogCommand from the jog queue.
+
+        :param timeout: The estimtated time the move will take for the queue timeout.
+        :return: The jog command or None if the stage stops before a command is
+            received.
+        """
+        while True:
+            try:
+                return self._jog_queue.get(timeout=timeout)
+            except queue.Empty:
+                if not self._poll_moving():
+                    # The stage is no longer moving, return None
+                    return None
+            # If we reached here then the stage is still moving shorten timeout and
+            # check again.
+            timeout = 0.1
+
     @lt.action
     def set_zero_position(self) -> None:
         """Make the current position zero in all axes.
diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 8e3ae14d..5bf69420 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -2,13 +2,10 @@
 
 from __future__ import annotations
 
-import queue
-import threading
 from collections.abc import Sequence
-from contextlib import contextmanager
 from copy import copy
 from types import TracebackType
-from typing import Any, Iterator, Literal, Optional, Self
+from typing import Any, Literal, Optional, Self
 
 import semver
 
@@ -21,40 +18,6 @@ REQUIRED_VERSION = semver.Version.parse("1.0.0")
 RECOMMENDED_VERSION = semver.Version.parse("1.0.4")
 
 
-class JogCommand:
-    """A base class for jog operations."""
-
-    def __init__(self) -> None:
-        """Initialise a JogCommand."""
-        super().__init__()
-        self.received = threading.Event()
-        self.finished = threading.Event()
-
-    def __repr__(self) -> str:
-        """Represent the command as a string."""
-        return f"<{self.__class__.__name__}>"
-
-
-class JogMoveCommand(JogCommand):
-    """A command to make a jog move."""
-
-    def __init__(self, displacement: Sequence[int]) -> None:
-        """Initialise a JogMoveCommand.
-
-        :param displacement: The displacement for the jog move, in hardware coordinates.
-        """
-        super().__init__()
-        self.displacement = displacement
-
-    def __repr__(self) -> str:
-        """Represent the command as a string."""
-        return f"<{self.__class__.__name__} {self.displacement}>"
-
-
-class JogStopCommand(JogCommand):
-    """A command to stop a jog move."""
-
-
 class SangaboardThing(BaseStage):
     """A Thing to manage a Sangaboard motor controller.
 
@@ -84,19 +47,14 @@ class SangaboardThing(BaseStage):
         """
         self.sangaboard_kwargs = copy(kwargs)
         self.sangaboard_kwargs["port"] = port
-        self._sangaboard_lock = threading.RLock()
-
-        self._jog_lock = threading.Lock()
-        self._jog_queue: queue.Queue[JogCommand] = queue.Queue[JogCommand](maxsize=1)
-        self._jog_thread: Optional[threading.Thread] = None
 
         super().__init__(thing_server_interface, **kwargs)
 
     def __enter__(self) -> Self:
         """Connect to the sangaboard when the Thing context manager is opened."""
         self._sangaboard = sangaboard.Sangaboard(**self.sangaboard_kwargs)
-        with self.sangaboard() as sb:
-            sb.query("blocking_moves false")
+        with self._hardware_lock:
+            self._sangaboard.query("blocking_moves false")
         self.check_firmware()
         self.update_position()
         return self
@@ -108,17 +66,8 @@ class SangaboardThing(BaseStage):
         _traceback: Optional[TracebackType],
     ) -> None:
         """Close the sangaboard connection when the Thing context manager is closed."""
-        with self.sangaboard() as sb:
-            sb.close()
-
-    @contextmanager
-    def sangaboard(self) -> Iterator[sangaboard.Sangaboard]:
-        """Return the wrapped ``sangaboard.Sangaboard`` instance.
-
-        This is protected by a ``threading.RLock``, which may change in future.
-        """
-        with self._sangaboard_lock:
-            yield self._sangaboard
+        with self._hardware_lock:
+            self._sangaboard.close()
 
     axis_inverted: dict[str, bool] = lt.setting(
         default={"x": True, "y": False, "z": True}, readonly=True
@@ -127,9 +76,9 @@ class SangaboardThing(BaseStage):
 
     def update_position(self) -> None:
         """Read position from the stage and set the corresponding property."""
-        with self.sangaboard() as sb:
+        with self._hardware_lock:
             self._hardware_position = dict(
-                zip(self.axis_names, sb.position, strict=True)
+                zip(self.axis_names, self._sangaboard.position, strict=True)
             )
 
     def check_firmware(self) -> None:
@@ -139,11 +88,11 @@ class SangaboardThing(BaseStage):
 
         Log a warning if the version is below RECOMMENDED_VERSION
         """
-        with self.sangaboard() as sb:
+        with self._hardware_lock:
             # This will raise a ValueError is if the firmware version cannot be parsed
             # this error will stop the microscope booting as we cannot ensure valid
             # firmware.
-            version = semver.Version.parse(sb.firmware_version)
+            version = semver.Version.parse(self._sangaboard.firmware_version)
 
             # Raise an error if version is below required
             if version < REQUIRED_VERSION:
@@ -165,21 +114,16 @@ class SangaboardThing(BaseStage):
         This starts the stage moving, but does not wait for the move to complete. It
         sets ``self.moving`` to ``True``: resetting it is the responsibility of the calling code.
         """
-        with self.sangaboard() as sb:
+        with self._hardware_lock:
             self.moving = True
-            sb.move_rel(displacement)
+            self._sangaboard.move_rel(displacement)
 
     def _hardware_stop(self) -> None:
         """Stop any motion of the stage as soon as possible."""
-        with self.sangaboard() as sb:
-            sb.query("stop")
+        with self._hardware_lock:
+            self._sangaboard.query("stop")
             self.moving = False
 
-    def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
-        """Calculate the expected duration of a move with the given displacement."""
-        max_displacement = max(abs(d) for d in displacement)
-        return max_displacement * 0.001  # This does not yet check the board's speed.
-
     def _poll_moving(self) -> bool:
         """Determine if the stage is still moving.
 
@@ -187,15 +131,15 @@ class SangaboardThing(BaseStage):
 
         :return: whether the stage is still moving.
         """
-        with self.sangaboard() as sb:
-            moving = sb.query("moving?") == "true"
+        with self._hardware_lock:
+            moving = self._sangaboard.query("moving?") == "true"
             if self.moving != moving:
                 self.moving = moving
             return moving
 
     def _poll_until_stopped(self) -> None:
         """Poll the stage until it reports that it has stopped moving."""
-        with self.sangaboard():
+        with self._hardware_lock:
             while self._poll_moving():
                 lt.cancellable_sleep(0.1)
 
@@ -207,17 +151,17 @@ class SangaboardThing(BaseStage):
         """Make a relative move in the coordinate system used by the sangaboard."""
         displacement = [kwargs.get(axis, 0) for axis in self.axis_names]
         duration = self._estimate_move_duration(displacement)
-        with self.sangaboard() as sb:
+        with self._hardware_lock:
             try:
-                sb.move_rel(displacement)
+                self._sangaboard.move_rel(displacement)
                 if block_cancellation:
-                    sb.query("notify_on_stop")
+                    self._sangaboard.query("notify_on_stop")
                 else:
                     if duration > 0.2:
                         lt.cancellable_sleep(
                             duration - 0.1
                         )  # Avoid unnecessary polling
-                    while sb.query("moving?") == "true":
+                    while self._sangaboard.query("moving?") == "true":
                         lt.cancellable_sleep(0.1)
             except lt.exceptions.InvocationCancelledError as e:
                 # If the move has been cancelled, stop it but don't handle the exception.
@@ -235,7 +179,7 @@ class SangaboardThing(BaseStage):
         **kwargs: int,
     ) -> None:
         """Make a absolute move in the coordinate system used by the sangaboard."""
-        with self.sangaboard():
+        with self._hardware_lock:
             self.update_position()
             displacement = {
                 axis: int(pos) - self._hardware_position[axis]
@@ -254,8 +198,8 @@ class SangaboardThing(BaseStage):
         It is intended for use after manually or automatically recentring the
         stage.
         """
-        with self.sangaboard() as sb:
-            sb.zero_position()
+        with self._hardware_lock:
+            self._sangaboard.zero_position()
         self.update_position()
 
     def set_led(
@@ -270,8 +214,8 @@ class SangaboardThing(BaseStage):
         being addressed.
         """
         led_command = f"led_{led_channel}"
-        with self.sangaboard() as sb:
-            return_value = sb.query(f"{led_command}?")
+        with self._hardware_lock:
+            return_value = self._sangaboard.query(f"{led_command}?")
             if not return_value.startswith("CC LED:"):
                 raise IOError("The sangaboard does not support LED control")
 
@@ -280,134 +224,6 @@ class SangaboardThing(BaseStage):
             # cannot be used.
             if led_on:
                 on_brightness = 0.32
-                sb.query(f"{led_command} {on_brightness}")
+                self._sangaboard.query(f"{led_command} {on_brightness}")
             else:
-                sb.query(f"{led_command} 0")
-
-    @lt.action
-    def jog(self, stop: bool = False, **kwargs: int) -> None:
-        """Make a relative move that may be interrupted by a future ``jog``.
-
-        This action makes a relative move. If another ``jog`` action is called while
-        a ``jog`` is already in progress, the first will be stopped and the second
-        will start immediately. This allows for responsive manual control of the
-        stage, for example with a joystick.
-
-        :param stop: if this is set to ``True`` the jog will be terminated.
-        :param kwargs: Keyword arguments should be axis names.
-        """
-        if stop:
-            self._send_jog_command(JogStopCommand(), timeout=1)
-        else:
-            self._hardware_jog(**self._apply_axis_direction(kwargs))
-
-    def _hardware_jog(self, **kwargs: int) -> None:
-        """Make a relative move that may be interrupted by a future ``jog``.
-
-        This function uses hardware coordinates, ``jog`` is the public wrapper that
-        applies any neecessary transform and then calls this function. See the
-        docs for that function for more explanation.
-
-        See `_jog_loop` for an explanation of the mechanism.
-
-        :param kwargs: Keyword arguments should be axis names.
-        """
-        move = [kwargs.get(axis, 0) for axis in self.axis_names]
-        self._send_jog_command(
-            JogMoveCommand(move),
-            timeout=self._estimate_move_duration(move) + 1,
-        )
-
-    def _send_jog_command(
-        self, command: JogCommand, timeout: Optional[float] = None
-    ) -> None:
-        """Send a jog command to the background jog thread.
-
-        This function will start the background thread if it is not running.
-        This function acquires ``_jog_lock`` and uses the ``_jog_send`` event to signal
-        the thread to read the next command. As commands interrupt each other, this
-        function should never block for a long time.
-
-        :param command: the jog command to send.
-        :param timeout: how long to wait for the command to be completed, or ``None``
-            to skip waiting.
-        """
-        if not self._jog_lock.acquire(timeout=0.1):
-            self.logger.warning(
-                "Could not send a jog message, this indicates a lock error."
-            )
-            return
-        try:
-            # Make sure the queue exists.
-            # Check the background thread is running, and restart it if not.
-            if self._jog_thread is None or not self._jog_thread.is_alive():
-                self.logger.info("Starting background thread for jog commands")
-                self._jog_queue = queue.Queue[JogCommand](maxsize=1)
-                self._jog_thread = threading.Thread(
-                    target=self._jog_loop, args=(command,)
-                )
-                self._jog_thread.start()
-            else:
-                self._jog_queue.put(command)
-            command.received.wait(1)
-        finally:
-            self._jog_lock.release()
-        # The final wait happens after releasing the lock: this allows jog moves to
-        # be interrupted.
-        if timeout is not None:
-            command.finished.wait(timeout)
-
-    def _jog_loop(self, first_command: JogCommand) -> None:
-        """Execute jog commands in a background thread.
-
-        This function is intended to be run in a background thread. It will look at
-        ``self._jog_command`` when the ``self._jog_send`` event is set, and signal that
-        the command is being processed with ``self._jog_received``.
-
-        If no new command is received before the current command finishes, the thread
-        will terminate, and ``self._jog_received`` will be set again. This means that
-        it should be safe to
-        """
-        # Timeout for checking queue
-        timeout = 0.1
-        previous_command: Optional[JogCommand] = None
-        command: Optional[JogCommand] = first_command
-
-        # prevent others using the sangaboard while jogging.
-        with self.sangaboard() as _sb:
-            while command is not None:
-                # Acknowledge the command
-                command.received.set()
-                if previous_command:
-                    # Notify the last command it's superseded
-                    previous_command.finished.set()
-                previous_command = command
-                if isinstance(command, JogMoveCommand):
-                    self._hardware_start_move_relative(command.displacement)
-                    timeout = self._estimate_move_duration(command.displacement)
-                elif isinstance(command, JogStopCommand):
-                    self._hardware_stop()
-                    # Next iteration, we will probably time out.
-                    timeout = 0.1
-                else:
-                    raise RuntimeError(f"Unknown jog command: {command}")
-                self.update_position()
-                command = self._get_from_jog_queue(timeout)
-
-    def _get_from_jog_queue(self, timeout: int) -> Optional[JogCommand]:
-        """Get the next JogCommand from the jog queue.
-
-        :param timeout: The estimtated time the move will take for the queue timeout.
-        :return: The jog command or None if the stage stops before a command is
-            received.
-        """
-        while True:
-            try:
-                return self._jog_queue.get(timeout=timeout)
-            except queue.Empty:
-                if not self._poll_moving():
-                    # The stage is no longer moving, return None
-                    return None
-            # If we reached here then the stage is still moving shorten timeout and
-            # check again.
-            timeout = 0.1
+                self._sangaboard.query(f"{led_command} 0")

From 61666a116bd4d1a3a5815bcf07dc4caa2840d0a9 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Thu, 12 Feb 2026 22:18:30 +0000
Subject: [PATCH 11/30] Simulation jog

---
 .../things/stage/__init__.py                  |  14 +-
 .../things/stage/dummy.py                     | 136 ++++++++++++++----
 .../things/stage/sangaboard.py                |   6 -
 3 files changed, 107 insertions(+), 49 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index c6f2fb78..a16ae89c 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -227,12 +227,7 @@ class BaseStage(lt.Thing):
         )
 
     def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
-        """Start a relative move.
-
-        This starts the stage moving, but does not wait for the move to complete. It
-        sets ``self.moving`` to ``True``: resetting it is the responsibility of the
-        calling code.
-        """
+        """Start a relative move."""
         raise NotImplementedError(
             "StageThings must define their own hardware_start_move_relative method"
         )
@@ -243,12 +238,7 @@ class BaseStage(lt.Thing):
         )
 
     def _poll_moving(self) -> bool:
-        """Determine if the stage is still moving.
-
-        This also sets ``moving`` if the status has changed.
-
-        :return: whether the stage is still moving.
-        """
+        """Determine if the stage is still moving."""
         raise NotImplementedError(
             "StageThings must define their own _poll_moving method"
         )
diff --git a/src/openflexure_microscope_server/things/stage/dummy.py b/src/openflexure_microscope_server/things/stage/dummy.py
index 7130fcb7..7e0f2bad 100644
--- a/src/openflexure_microscope_server/things/stage/dummy.py
+++ b/src/openflexure_microscope_server/things/stage/dummy.py
@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
+import threading
 import time
+from collections.abc import Sequence
 from types import TracebackType
-from typing import Any, Optional, Self
+from typing import Any, Mapping, Optional, Self
 
 import labthings_fastapi as lt
 
@@ -32,8 +34,11 @@ class DummyStage(BaseStage):
             also doing computationally heavy tasks like simulated image blurring.
         """
         super().__init__(thing_server_interface, **kwargs)
+        self._move_thread: Optional[threading.Thread] = None
         self.step_time = step_time
-        self.instantaneous_position = self._hardware_position
+        self.instantaneous_position: Mapping[str, int] = self._hardware_position
+        self._inst_pos_lock = threading.Lock()
+        self._abort_move = threading.Event()
 
     def __enter__(self) -> Self:
         """Register the stage position when the Thing context manager is opened."""
@@ -53,43 +58,111 @@ class DummyStage(BaseStage):
     )
     """Used to convert coordinates between the program frame and the hardware frame."""
 
-    def _hardware_move_relative(
-        self,
-        block_cancellation: bool = False,
-        **kwargs: int,
-    ) -> None:
-        """Make a relative move. Keyword arguments should be axis names."""
-        displacement = [kwargs.get(k, 0) for k in self.axis_names]
-        self.moving = True
+    def update_position(self) -> None:
+        """Read position from the stage and set the corresponding property."""
+        pass
+
+    def _calc_fractional_pos(
+        self, displacement: Sequence[int], fraction_complete: float
+    ) -> dict[str, int]:
+        """Calculate the position a fraction through a move."""
+        return {
+            ax: self._hardware_position[ax] + int(fraction_complete * disp)
+            for ax, disp in zip(self.axis_names, displacement, strict=True)
+        }
+
+    def _apply_move(self, displacement: Sequence[int]) -> None:
         try:
             fraction_complete = 0.0
             dt = self.step_time
             max_displacement = max(abs(v) for v in displacement)
             start_time = time.time()
             while time.time() - start_time < dt * max_displacement:
-                if block_cancellation:
-                    time.sleep(dt)
-                else:
-                    lt.cancellable_sleep(dt)
+                if self._abort_move.is_set():
+                    break
                 fraction_complete = (time.time() - start_time) / (dt * max_displacement)
-                self.instantaneous_position = {
-                    ax: self._hardware_position[ax] + int(fraction_complete * disp)
-                    for ax, disp in zip(self.axis_names, displacement, strict=True)
-                }
-            fraction_complete = 1.0
-        except lt.exceptions.InvocationCancelledError as e:
-            # If the move has been cancelled, stop it but don't handle the exception.
-            # We need the exception to propagate in order to stop any calling tasks,
-            # and to mark the invocation as "cancelled" rather than stopped.
-            raise e
+                self.instantaneous_position = self._calc_fractional_pos(
+                    displacement, fraction_complete
+                )
+            if not self._abort_move.is_set():
+                fraction_complete = 1.0
         finally:
-            self.moving = False
-            self._hardware_position = {
-                ax: self._hardware_position[ax] + int(fraction_complete * disp)
-                for ax, disp in zip(self.axis_names, displacement, strict=True)
-            }
+            self._hardware_position = self._calc_fractional_pos(
+                displacement, fraction_complete
+            )
             self.instantaneous_position = self._hardware_position
 
+    def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
+        """Start a relative move.
+
+        This starts the stage moving, but does not wait for the move to complete. It
+        sets ``self.moving`` to ``True``: resetting it is the responsibility of the
+        calling code.
+        """
+        with self._hardware_lock:
+            self.moving = True
+            self._abort_move.clear()
+            self._move_thread = threading.Thread(
+                target=self._apply_move, args=(displacement,)
+            )
+            self._move_thread.start()
+
+    def _hardware_stop(self) -> None:
+        with self._hardware_lock:
+            self._abort_move.set()
+            self.moving = False
+
+    def _poll_moving(self) -> bool:
+        """Determine if the stage is still moving."""
+        if self._move_thread is None:
+            return False
+        moving = self._move_thread.is_alive()
+        if self.moving != moving:
+            self.moving = moving
+        return moving
+
+    def _hardware_move_relative(
+        self,
+        block_cancellation: bool = False,
+        **kwargs: int,
+    ) -> None:
+        """Make a relative move. Keyword arguments should be axis names."""
+        with self._hardware_lock:
+            displacement = [kwargs.get(k, 0) for k in self.axis_names]
+            self.moving = True
+            # This follows a similar structure to _apply_move but need a different
+            # breakning mechanism. Running apply move in a thread and breaking here
+            # results in significantly worse autofocus
+            try:
+                fraction_complete = 0.0
+                dt = self.step_time
+                max_displacement = max(abs(v) for v in displacement)
+                start_time = time.time()
+                while time.time() - start_time < dt * max_displacement:
+                    if block_cancellation:
+                        time.sleep(self.step_time)
+                    else:
+                        lt.cancellable_sleep(self.step_time)
+                    fraction_complete = (time.time() - start_time) / (
+                        dt * max_displacement
+                    )
+                    self.instantaneous_position = self._calc_fractional_pos(
+                        displacement, fraction_complete
+                    )
+                fraction_complete = 1.0
+            except lt.exceptions.InvocationCancelledError as e:
+                # If the move has been cancelled, stop it but don't handle the
+                # exception. We need the exception to propagate in order to stop
+                # any calling tasks, and to mark the invocation as "cancelled"
+                # rather than stopped.
+                raise e
+            finally:
+                self._hardware_position = self._calc_fractional_pos(
+                    displacement, fraction_complete
+                )
+                self.instantaneous_position = self._hardware_position
+                self.moving = False
+
     def _hardware_move_absolute(
         self,
         block_cancellation: bool = False,
@@ -113,5 +186,6 @@ class DummyStage(BaseStage):
         It is intended for use after manually or automatically recentring the
         stage.
         """
-        self._hardware_position = dict.fromkeys(self.axis_names, 0)
-        self.instantaneous_position = self._hardware_position
+        with self._hardware_lock:
+            self._hardware_position = dict.fromkeys(self.axis_names, 0)
+            self.instantaneous_position = self._hardware_position
diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 5bf69420..e17df882 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -137,12 +137,6 @@ class SangaboardThing(BaseStage):
                 self.moving = moving
             return moving
 
-    def _poll_until_stopped(self) -> None:
-        """Poll the stage until it reports that it has stopped moving."""
-        with self._hardware_lock:
-            while self._poll_moving():
-                lt.cancellable_sleep(0.1)
-
     def _hardware_move_relative(
         self,
         block_cancellation: bool = False,

From 586d45aed3489234722c8f18da7d5c0e9bb06c0f Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 01:02:55 +0000
Subject: [PATCH 12/30] Debounce keyboard repeats for smoother movement

---
 webapp/src/App.vue                            | 96 ++++++++++---------
 .../controlComponents/positionControl.vue     |  6 +-
 2 files changed, 55 insertions(+), 47 deletions(-)

diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index 5aed7071..e3c6443c 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -29,6 +29,8 @@ import loadingContent from "./components/loadingContent.vue";
 import Mousetrap from "mousetrap";
 import { eventBus } from "./eventBus.js";
 
+const move_keys = ["up", "down", "left", "right", "pageup", "pagedown"];
+
 Mousetrap.prototype.stopCallback = function (e, element) {
   // if the element has the class "mousetrap" then no need to stop
   if ((" " + element.className + " ").indexOf(" Mousetrap ") > -1) {
@@ -65,6 +67,10 @@ export default {
       keyboardManual: [],
       systemDark: undefined,
       themeObserver: undefined,
+      keysDown: new Set(),
+      lastJogTime: 0,
+      jogDistance: 600,
+      jogTime: 300,
     };
   },
 
@@ -130,42 +136,31 @@ export default {
       this.toggleModalElement(this.$refs["keyboardManualModal"]); // Calls the mixin
     });
 
-    // Arrow keys
     Mousetrap.bind(
-      ["up", "down", "left", "right"],
-      (event) => {
-        this.arrowKeysDown[event.keyCode] = true; //Add key to array
-        this.navigateKeyHandler();
+      move_keys,
+      (event, key) => {
+        event.preventDefault();
+        this.keysDown.add(key);
+        this.updateJogFromKeys();
       },
       "keydown",
     );
+
     Mousetrap.bind(
-      ["up", "down", "left", "right"],
-      (event) => {
-        delete this.arrowKeysDown[event.keyCode]; //Remove key from array
-        this.invokeAction("stage", "jog", { stop: true });
+      move_keys,
+      (event, key) => {
+        event.preventDefault();
+        this.keysDown.delete(key);
+        this.updateJogFromKeys();
       },
       "keyup",
     );
+
     this.keyboardManual.push({
       shortcut: "←↑→↓",
       description: "Move the microscope stage",
     });
 
-    // Focus keys
-    Mousetrap.bind("pageup", () => {
-      eventBus.emit("globalMoveStepEvent", { x: 0, y: 0, z: 1 });
-    });
-    Mousetrap.bind("pagedown", () => {
-      eventBus.emit("globalMoveStepEvent", { x: 0, y: 0, z: -1 });
-    });
-    Mousetrap.bind(
-      ["pageup", "pagedown"],
-      () => {
-        this.invokeAction("stage", "jog", { stop: true });
-      },
-      "keyup",
-    );
     this.keyboardManual.push({
       shortcut: "pgup / pgdn",
       description: "Move the microscope focus",
@@ -266,29 +261,42 @@ export default {
       }
     },
 
-    navigateKeyHandler: function () {
-      // Calculate movement array
-      var x_rel = 0;
-      var y_rel = 0;
-      // 37 corresponds to the left key
-      if (37 in this.arrowKeysDown) {
-        x_rel = x_rel - 1;
+    jog(x, y, z) {
+      // Manually debounce extra requests from keyboard repeat rate.
+      // This is used rather than and interval in case of missing a repeat.
+      const now = Date.now();
+      if (now - this.lastJogTime < this.jogTime) {
+        return;
       }
-      // 39 corresponds to the right key
-      if (39 in this.arrowKeysDown) {
-        x_rel = x_rel + 1;
+      this.lastJogTime = now;
+
+      this.invokeAction("stage", "jog", {
+        x: x * this.jogDistance,
+        y: y * this.jogDistance,
+        z: z * this.jogDistance,
+      });
+    },
+
+    jogStop() {
+      this.invokeAction("stage", "jog", { stop: true });
+    },
+
+    updateJogFromKeys() {
+      let x = 0,
+        y = 0,
+        z = 0;
+      if (this.keysDown.has("left")) x -= 1;
+      if (this.keysDown.has("right")) x += 1;
+      if (this.keysDown.has("up")) y += 1;
+      if (this.keysDown.has("down")) y -= 1;
+      if (this.keysDown.has("pageup")) z += 1;
+      if (this.keysDown.has("pagedown")) z -= 1;
+
+      if (x || y || z) {
+        this.jog(x, y, z);
+      } else {
+        this.jogStop();
       }
-      // 38 corresponds to the up key
-      if (38 in this.arrowKeysDown) {
-        y_rel = y_rel + 1;
-      }
-      // 40 corresponds to the down key
-      if (40 in this.arrowKeysDown) {
-        y_rel = y_rel - 1;
-      }
-      // Make a position request
-      // Emit a signal to move, acted on by panelControl.vue
-      eventBus.emit("globalMoveStepEvent", { x: x_rel, y: y_rel, z: 0 });
     },
   },
 };
diff --git a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
index 4ad060ae..000a74dd 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
@@ -120,9 +120,9 @@ export default {
     onMoveStep(payload) {
       const navigationStepSize = this.$store.state.navigationStepSize;
       const navigationInvert = this.$store.state.navigationInvert;
-      const x = x_steps * navigationStepSize.x * (navigationInvert.x ? -1 : 1);
-      const y = y_steps * navigationStepSize.y * (navigationInvert.y ? -1 : 1);
-      const z = z_steps * navigationStepSize.z * (navigationInvert.z ? -1 : 1);
+      const x = payload.x_steps * navigationStepSize.x * (navigationInvert.x ? -1 : 1);
+      const y = payload.y_steps * navigationStepSize.y * (navigationInvert.y ? -1 : 1);
+      const z = payload.z_steps * navigationStepSize.z * (navigationInvert.z ? -1 : 1);
       this.invokeAction("stage", "jog", { x: x, y: y, z: z });
     },
 

From 84488b579b8599e8d3cdd1b4a8769b8b972eb108 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 09:14:22 +0000
Subject: [PATCH 13/30] Re-implement stage button inversion and update position
 during move.

---
 webapp/src/App.vue                            | 24 ++++++++++++-------
 .../controlComponents/positionControl.vue     | 11 ---------
 .../controlComponents/stageControlButtons.vue | 10 ++++++--
 3 files changed, 23 insertions(+), 22 deletions(-)

diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index e3c6443c..917f5dcd 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -250,14 +250,14 @@ export default {
         event.target.parentNode.classList.contains("scrollTarget") ||
         event.target.classList.contains("scrollTarget")
       ) {
-        const z_steps = event.deltaY / 100;
+        const z_rel = event.deltaY / 100;
         // Emit a signal to move, acted on by panelControl.vue
-        eventBus.emit("globalMoveStepEvent", {
-          x_steps: 0,
-          y_steps: 0,
-          z_steps: z_steps,
-          absolute: false,
-        });
+        const navigationStepSize = this.$store.state.navigationStepSize;
+        const z = z_rel * navigationStepSize.z;
+        // Don't use `jog() due to variable size of jogs here and the rate limiting in
+        // `jog()`. No need to invert on z, as navigationInvert.z isn't exposed.
+        this.invokeAction("stage", "jog", { x: 0, y: 0, z: z });
+        eventBus.emit("globalUpdatePositionEvent");
       }
     },
 
@@ -265,20 +265,26 @@ export default {
       // Manually debounce extra requests from keyboard repeat rate.
       // This is used rather than and interval in case of missing a repeat.
       const now = Date.now();
+      const navigationInvert = this.$store.state.navigationInvert;
       if (now - this.lastJogTime < this.jogTime) {
         return;
       }
       this.lastJogTime = now;
 
       this.invokeAction("stage", "jog", {
-        x: x * this.jogDistance,
-        y: y * this.jogDistance,
+        x: x * this.jogDistance * (navigationInvert.x ? -1 : 1),
+        y: y * this.jogDistance * (navigationInvert.y ? -1 : 1),
         z: z * this.jogDistance,
       });
+      eventBus.emit("globalUpdatePositionEvent");
     },
 
     jogStop() {
       this.invokeAction("stage", "jog", { stop: true });
+      this.lastJogTime = 0;
+      setTimeout(() => {
+        eventBus.emit("globalUpdatePositionEvent");
+      }, 100);
     },
 
     updateJogFromKeys() {
diff --git a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
index 000a74dd..dda20aeb 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
@@ -94,7 +94,6 @@ export default {
     // A global signal listener to perform a move action in pixels
     eventBus.on("globalMoveInImageCoordinatesEvent", this.onMoveImage);
     // A global signal listener to perform a move in multiples of a step size
-    eventBus.on("globalMoveStepEvent", this.onMoveStep);
 
     // Update the current position in text boxes
     await this.updatePosition();
@@ -105,7 +104,6 @@ export default {
     eventBus.off("globalMoveEvent", this.move);
     eventBus.off("globalUpdatePositionEvent", this.updatePosition);
     eventBus.off("globalMoveInImageCoordinatesEvent", this.onMoveImage);
-    eventBus.off("globalMoveStepEvent", this.onMoveStep);
   },
 
   methods: {
@@ -117,15 +115,6 @@ export default {
       this.moveInImageCoordinatesRequest(payload.x, payload.y, payload.absolute);
     },
 
-    onMoveStep(payload) {
-      const navigationStepSize = this.$store.state.navigationStepSize;
-      const navigationInvert = this.$store.state.navigationInvert;
-      const x = payload.x_steps * navigationStepSize.x * (navigationInvert.x ? -1 : 1);
-      const y = payload.y_steps * navigationStepSize.y * (navigationInvert.y ? -1 : 1);
-      const z = payload.z_steps * navigationStepSize.z * (navigationInvert.z ? -1 : 1);
-      this.invokeAction("stage", "jog", { x: x, y: y, z: z });
-    },
-
     async move(payload) {
       const { x, y, z, absolute } = payload;
       // Move the stage, by updating the controls and starting a move task
diff --git a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
index f88b9524..b8882bac 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
@@ -65,6 +65,8 @@
 </template>
 
 <script>
+import { eventBus } from "@/eventBus.js";
+
 export default {
   name: "StageControlButtons",
   data: () => ({
@@ -77,10 +79,11 @@ export default {
       if (this.jogIntervalId) {
         clearInterval(this.jogIntervalId);
       }
+      const navigationInvert = this.$store.state.navigationInvert;
       let invokeJog = () =>
         this.invokeAction("stage", "jog", {
-          x: x * this.jogDistance,
-          y: y * this.jogDistance,
+          x: x * this.jogDistance * (navigationInvert.x ? -1 : 1),
+          y: y * this.jogDistance * (navigationInvert.y ? -1 : 1),
           z: z * this.jogDistance,
         });
       invokeJog();
@@ -91,6 +94,9 @@ export default {
         clearInterval(this.jogIntervalId);
       }
       this.invokeAction("stage", "jog", { stop: true });
+      setTimeout(() => {
+        eventBus.emit("globalUpdatePositionEvent");
+      }, 100);
     },
   },
 };

From a1ceb1fc5ef895c2c5ecbb15f61ed0b89d82cf1e Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 09:45:28 +0000
Subject: [PATCH 14/30] Jog buttons in calibration wizard

---
 .../csmSteps/focusStep.vue                    | 45 ++--------------
 .../controlComponents/stageControlButtons.vue | 52 +++++++++++++++++--
 2 files changed, 52 insertions(+), 45 deletions(-)

diff --git a/webapp/src/components/modalComponents/calibrationWizardComponents/csmSteps/focusStep.vue b/webapp/src/components/modalComponents/calibrationWizardComponents/csmSteps/focusStep.vue
index e6a89c52..847a4a2b 100644
--- a/webapp/src/components/modalComponents/calibrationWizardComponents/csmSteps/focusStep.vue
+++ b/webapp/src/components/modalComponents/calibrationWizardComponents/csmSteps/focusStep.vue
@@ -3,58 +3,21 @@
     <p>Use the buttons below to bring the sample into focus.</p>
     <p>You may also adjust the z position with <b>page up</b> and <b>page down</b>.</p>
     <template #below-stream>
-      <div class="action-button-container">
-        <action-button
-          class="moveZ"
-          thing="stage"
-          action="move_relative"
-          :button-primary="false"
-          :submit-data="{ x: 0, y: 0, z: -100 }"
-          :submit-label="' - '"
-          :can-terminate="false"
-        />
-        <action-button
-          class="moveZ"
-          thing="stage"
-          action="move_relative"
-          :button-primary="false"
-          :submit-data="{ x: 0, y: 0, z: 100 }"
-          :submit-label="'+'"
-          :can-terminate="false"
-        />
-      </div>
+      <stageControlButtons :show-dpad="false" />
     </template>
   </stepTemplateWithStream>
 </template>
 
 <script>
 import stepTemplateWithStream from "../stepTemplateWithStream.vue";
-import ActionButton from "../../../labThingsComponents/actionButton.vue";
-
+import stageControlButtons from "@/components/tabContentComponents/controlComponents/stageControlButtons.vue";
 export default {
   name: "CameraMainCalibrationStep",
 
   components: {
     stepTemplateWithStream,
-    ActionButton,
+    stageControlButtons,
   },
 };
 </script>
-<style scoped>
-.action-button-container {
-  display: flex;
-  flex-direction: row; /* Stack vertically */
-  justify-content: center; /* Left align */
-  gap: 8px; /* Small space between buttons */
-  margin-top: 4px; /* Gap from image */
-}
-.moveZ :deep(.uk-button.uk-width-1-1) {
-  line-height: 50px;
-  font-size: 50px !important;
-  height: 60px;
-  padding-bottom: 46px;
-  margin: 0; /* Remove default margin */
-  width: 120px;
-  min-width: 80px;
-}
-</style>
+<style scoped></style>
diff --git a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
index b8882bac..cb5b7278 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
@@ -1,7 +1,15 @@
 <template>
   <div class="uk-flex uk-flex-center uk-flex-middle uk-margin">
-    <div class="dpad-grid">
+    <div
+      class="dpad-grid"
+      :class="{
+        'dpad-only': showDpad && !showFocusControls,
+        'focus-only': !showDpad && showFocusControls,
+        'both-controls': showDpad && showFocusControls,
+      }"
+    >
       <button
+        v-if="showDpad"
         id="up-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(0, 1, 0)"
@@ -12,6 +20,7 @@
       </button>
 
       <button
+        v-if="showDpad"
         id="left-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(-1, 0, 0)"
@@ -22,6 +31,7 @@
       </button>
 
       <button
+        v-if="showDpad"
         id="right-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(1, 0, 0)"
@@ -32,6 +42,7 @@
       </button>
 
       <button
+        v-if="showDpad"
         id="down-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(0, -1, 0)"
@@ -42,6 +53,7 @@
       </button>
 
       <button
+        v-if="showFocusControls"
         id="focus-out-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(0, 0, -1)"
@@ -52,6 +64,7 @@
       </button>
 
       <button
+        v-if="showFocusControls"
         id="focus-in-button"
         class="uk-button uk-button-primary dpad-btn"
         @mousedown="jog(0, 0, 1)"
@@ -69,6 +82,16 @@ import { eventBus } from "@/eventBus.js";
 
 export default {
   name: "StageControlButtons",
+  props: {
+    showDpad: {
+      type: Boolean,
+      default: true,
+    },
+    showFocusControls: {
+      type: Boolean,
+      default: true,
+    },
+  },
   data: () => ({
     jogIntervalId: null,
     jogDistance: 600,
@@ -106,12 +129,23 @@ export default {
 .dpad-grid {
   display: grid;
   grid-template-columns: repeat(3, 40px);
-  grid-template-rows: 40px 40px 40px 20px 40px;
   gap: 1px;
   justify-content: center;
   align-items: center;
 }
 
+.both-controls {
+  grid-template-rows: 40px 40px 40px 20px 40px;
+}
+
+.dpad-only {
+  grid-template-rows: 40px 40px 40px;
+}
+
+.focus-only {
+  grid-template-rows: 40px;
+}
+
 /* Place buttons within grid */
 .dpad-grid #up-button {
   grid-column: 2;
@@ -129,15 +163,25 @@ export default {
   grid-column: 2;
   grid-row: 3;
 }
-.dpad-grid #focus-out-button {
+
+.both-controls #focus-out-button {
   grid-column: 1;
   grid-row: 5;
 }
-.dpad-grid #focus-in-button {
+.both-controls #focus-in-button {
   grid-column: 3;
   grid-row: 5;
 }
 
+.focus-only #focus-out-button {
+  grid-column: 1;
+  grid-row: 1;
+}
+.focus-only #focus-in-button {
+  grid-column: 3;
+  grid-row: 1;
+}
+
 .dpad-btn {
   width: 40px;
   height: 40px;

From d9ba5d906df8740d46fd879cd73e79fdb95c5438 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 09:51:14 +0000
Subject: [PATCH 15/30] No jog when right-click on d-pad

---
 .../controlComponents/stageControlButtons.vue        | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
index cb5b7278..158823d2 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
@@ -12,7 +12,7 @@
         v-if="showDpad"
         id="up-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(0, 1, 0)"
+        @mousedown.left="jog(0, 1, 0)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >
@@ -23,7 +23,7 @@
         v-if="showDpad"
         id="left-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(-1, 0, 0)"
+        @mousedown.left="jog(-1, 0, 0)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >
@@ -34,7 +34,7 @@
         v-if="showDpad"
         id="right-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(1, 0, 0)"
+        @mousedown.left="jog(1, 0, 0)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >
@@ -45,7 +45,7 @@
         v-if="showDpad"
         id="down-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(0, -1, 0)"
+        @mousedown.left="jog(0, -1, 0)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >
@@ -56,7 +56,7 @@
         v-if="showFocusControls"
         id="focus-out-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(0, 0, -1)"
+        @mousedown.left="jog(0, 0, -1)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >
@@ -67,7 +67,7 @@
         v-if="showFocusControls"
         id="focus-in-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown="jog(0, 0, 1)"
+        @mousedown.left="jog(0, 0, 1)"
         @mouseup="jogStop()"
         @mouseOut="jogStop()"
       >

From 8478194e30a1e916eb13ca5ffd949640e853dc6f Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 10:36:13 +0000
Subject: [PATCH 16/30] Better jog comments, use pointer events for robustness

---
 webapp/src/App.vue                            | 21 ++++++-
 .../controlComponents/stageControlButtons.vue | 58 +++++++++++++------
 2 files changed, 59 insertions(+), 20 deletions(-)

diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index 917f5dcd..671e3d39 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -243,7 +243,9 @@ export default {
       eventBus.emit("globalTogglePreview", false);
     },
 
-    // Handle global mouse wheel events to be associated with navigation
+    /**
+     *  Handle global mouse wheel events to be associated with navigation
+     */
     wheelMonitor: function (event) {
       // Only capture scroll if the event target's parent contains the "scrollTarget" class
       if (
@@ -261,6 +263,13 @@ export default {
       }
     },
 
+    /**
+     * Jog for key-presses.
+     *
+     * This is a similar to the function in stageControlButtons.vue however it uses
+     * uses the key repeat to fire in case a key up is missed. It debounes any
+     * request to jog that is too recent after the last jog.
+     */
     jog(x, y, z) {
       // Manually debounce extra requests from keyboard repeat rate.
       // This is used rather than and interval in case of missing a repeat.
@@ -279,6 +288,13 @@ export default {
       eventBus.emit("globalUpdatePositionEvent");
     },
 
+    /**
+     * Stop jogging on key-up
+     *
+     * This is also similar to the function in stageControlButtons.vue. It handles
+     * stopping jogging and resetting the `lastJogTime` so there is no delay when
+     * starting a new jog after an old jog finished.
+     */
     jogStop() {
       this.invokeAction("stage", "jog", { stop: true });
       this.lastJogTime = 0;
@@ -287,6 +303,9 @@ export default {
       }, 100);
     },
 
+    /**
+     * Track which keys are still down on keypress (or key repeat).
+     */
     updateJogFromKeys() {
       let x = 0,
         y = 0,
diff --git a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
index 158823d2..f75a08a4 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/stageControlButtons.vue
@@ -12,9 +12,9 @@
         v-if="showDpad"
         id="up-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(0, 1, 0)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, 0, 1, 0)"
+        @pointerup="jogStop()"
+        @mouseLeave="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> arrow_upward </span>
       </button>
@@ -23,9 +23,9 @@
         v-if="showDpad"
         id="left-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(-1, 0, 0)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, -1, 0, 0)"
+        @pointerup="jogStop()"
+        @pointercancel="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> arrow_back </span>
       </button>
@@ -34,9 +34,9 @@
         v-if="showDpad"
         id="right-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(1, 0, 0)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, 1, 0, 0)"
+        @pointerup="jogStop()"
+        @pointercancel="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> arrow_forward </span>
       </button>
@@ -45,9 +45,9 @@
         v-if="showDpad"
         id="down-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(0, -1, 0)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, 0, -1, 0)"
+        @pointerup="jogStop()"
+        @pointercancel="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> arrow_downward </span>
       </button>
@@ -56,9 +56,9 @@
         v-if="showFocusControls"
         id="focus-out-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(0, 0, -1)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, 0, 0, -1)"
+        @pointerup="jogStop()"
+        @pointercancel="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> remove </span>
       </button>
@@ -67,9 +67,9 @@
         v-if="showFocusControls"
         id="focus-in-button"
         class="uk-button uk-button-primary dpad-btn"
-        @mousedown.left="jog(0, 0, 1)"
-        @mouseup="jogStop()"
-        @mouseOut="jogStop()"
+        @pointerdown="jog($event, 0, 0, 1)"
+        @pointerup="jogStop()"
+        @pointercancel="jogStop()"
       >
         <span class="material-symbols-outlined sync-icon"> add </span>
       </button>
@@ -98,10 +98,24 @@ export default {
     jogTime: 300,
   }),
   methods: {
-    jog(x, y, z) {
+    /**
+     * Jog d-pad and focus buttons.
+     *
+     * This is a similar to the function in App.vue, however it uses an Interval rather
+     * than the one in App.vue that uses key repeats.
+     */
+    jog(keyevent, x, y, z) {
+      // Only respond to primary button (left mouse / primary touch)
+      if (keyevent.button !== 0) return;
+
       if (this.jogIntervalId) {
         clearInterval(this.jogIntervalId);
       }
+
+      // Designate this element to get the pointers next pointerup event wherever that
+      // pointer is.
+      keyevent.target.setPointerCapture(keyevent.pointerId);
+
       const navigationInvert = this.$store.state.navigationInvert;
       let invokeJog = () =>
         this.invokeAction("stage", "jog", {
@@ -112,6 +126,12 @@ export default {
       invokeJog();
       this.jogIntervalId = setInterval(invokeJog, this.jogTime);
     },
+    /**
+     * Stop jogging from d-pad and focus buttons.
+     *
+     * This is a similar to the function in App.vue, but it is designed to clear the
+     * interval used with the d-pad and focus buttons.
+     */
     jogStop() {
       if (this.jogIntervalId) {
         clearInterval(this.jogIntervalId);

From f1d974c922a9b218387f41016f41f568fad4cd4b Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 10:49:10 +0000
Subject: [PATCH 17/30] Improve some jogging docstrings

---
 .../things/stage/__init__.py                           |  6 +++++-
 .../things/stage/dummy.py                              | 10 ++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index a16ae89c..e42e64e2 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -33,7 +33,11 @@ class RedefinedBaseMovementError(RuntimeError):
 
 
 class JogCommand:
-    """A base class for jog operations."""
+    """A base class for jog operations.
+
+    This class handles threading events used to interrupt previous jog commands. There
+    are two subclasses that are used by jogging `JogMoveCommand` and `JogStopCommand`.
+    """
 
     def __init__(self) -> None:
         """Initialise a JogCommand."""
diff --git a/src/openflexure_microscope_server/things/stage/dummy.py b/src/openflexure_microscope_server/things/stage/dummy.py
index 7e0f2bad..51af444e 100644
--- a/src/openflexure_microscope_server/things/stage/dummy.py
+++ b/src/openflexure_microscope_server/things/stage/dummy.py
@@ -72,6 +72,16 @@ class DummyStage(BaseStage):
         }
 
     def _apply_move(self, displacement: Sequence[int]) -> None:
+        """Make a move, this function is designed to be run in a thread by jogging.
+
+        This can't be used for normal movements as the delays setting up the extra
+        threads causes autofucs to fail. As such `_hardware_move_relative` is similarly
+        structured.
+
+        Interrupt this function with the ``self._abort_move`` event.
+
+        :param displacement: The (x, y, z) position.
+        """
         try:
             fraction_complete = 0.0
             dt = self.step_time

From 728880e49d63e20d2f16744eaae27b9e7102fd73 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 16:20:20 +0000
Subject: [PATCH 18/30] Fix jog queue blocking waiting to put new commands.

---
 .../things/stage/__init__.py                  | 23 +++++++++++++++++--
 tests/unit_tests/test_stage.py                | 15 ++++++++++++
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index e42e64e2..08762c1e 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -70,6 +70,25 @@ class JogStopCommand(JogCommand):
     """A command to stop a jog move."""
 
 
+class JogQueue(queue.Queue[JogCommand]):
+    """A class queue for JogCommands. This always returns the most recent command."""
+
+    def __init__(self) -> None:
+        """Set up a queue with a max size of 1."""
+        super().__init__(maxsize=1)
+
+    def put(
+        self, item: JogCommand, block: bool = False, timeout: Optional[float] = None
+    ) -> None:
+        """Put the next command into the queue, bumping anything already there."""
+        try:
+            # First remove existing item if present
+            self.get_nowait()
+        except queue.Empty:
+            pass
+        super().put(item, block=block, timeout=timeout)
+
+
 class BaseStage(lt.Thing):
     """A base stage class for OpenFlexure translation stages.
 
@@ -97,7 +116,7 @@ class BaseStage(lt.Thing):
         super().__init__(thing_server_interface)
         self._hardware_lock = threading.RLock()
         self._jog_lock = threading.Lock()
-        self._jog_queue: queue.Queue[JogCommand] = queue.Queue[JogCommand](maxsize=1)
+        self._jog_queue = JogQueue()
         self._jog_thread: Optional[threading.Thread] = None
         self._hardware_position = dict.fromkeys(self._axis_names, 0)
 
@@ -310,7 +329,7 @@ class BaseStage(lt.Thing):
             # Check the background thread is running, and restart it if not.
             if self._jog_thread is None or not self._jog_thread.is_alive():
                 self.logger.info("Starting background thread for jog commands")
-                self._jog_queue = queue.Queue[JogCommand](maxsize=1)
+                self._jog_queue = JogQueue()
                 self._jog_thread = threading.Thread(
                     target=self._jog_loop, args=(command,)
                 )
diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 25c19fa1..1b2025f5 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -12,6 +12,7 @@ from labthings_fastapi.testing import create_thing_without_server
 from openflexure_microscope_server.things.camera.simulation import SimulatedCamera
 from openflexure_microscope_server.things.stage import (
     BaseStage,
+    JogMoveCommand,
     RedefinedBaseMovementError,
 )
 from openflexure_microscope_server.things.stage.dummy import DummyStage
@@ -300,3 +301,17 @@ def test_thing_description_equivalence(dummy_stage, mocker):
 
     assert sanga_actions == dummy_actions == base_actions
     assert sanga_properties == dummy_properties == base_properties
+
+
+def test_get_jog_from_queue_most_recent(dummy_stage):
+    """Test that the jog queue gives the most recent Jog Command."""
+    # Try to stack 4 moves in the queue, only 1 should be queued.
+    for i in range(4):
+        dummy_stage._jog_queue.put(JogMoveCommand([i, i, i]))
+
+    command = dummy_stage._get_from_jog_queue(0.001)
+    assert isinstance(command, JogMoveCommand)
+    # Should be the last one queued
+    assert command.displacement == [3, 3, 3]
+    # Nothing else is queued
+    assert dummy_stage._get_from_jog_queue(0.001) is None

From eb799055813b212174ff4ac855a3b81c50b38dc6 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 16:36:14 +0000
Subject: [PATCH 19/30] Removed the received Event as waiting for forces every
 jog to be queued and dequeued

---
 .../things/stage/__init__.py                          | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index 08762c1e..74a43429 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -42,7 +42,6 @@ class JogCommand:
     def __init__(self) -> None:
         """Initialise a JogCommand."""
         super().__init__()
-        self.received = threading.Event()
         self.finished = threading.Event()
 
     def __repr__(self) -> str:
@@ -336,7 +335,6 @@ class BaseStage(lt.Thing):
                 self._jog_thread.start()
             else:
                 self._jog_queue.put(command)
-            command.received.wait(1)
         finally:
             self._jog_lock.release()
         # The final wait happens after releasing the lock: this allows jog moves to
@@ -348,12 +346,7 @@ class BaseStage(lt.Thing):
         """Execute jog commands in a background thread.
 
         This function is intended to be run in a background thread. It will look at
-        ``self._jog_command`` when the ``self._jog_send`` event is set, and signal that
-        the command is being processed with ``self._jog_received``.
-
-        If no new command is received before the current command finishes, the thread
-        will terminate, and ``self._jog_received`` will be set again. This means that
-        it should be safe to
+        ``self._jog_command`` when the ``self._jog_send`` event is set.
         """
         # Timeout for checking queue
         timeout = 0.1
@@ -363,8 +356,6 @@ class BaseStage(lt.Thing):
         # prevent others using the stage while jogging.
         with self._hardware_lock:
             while command is not None:
-                # Acknowledge the command
-                command.received.set()
                 if previous_command:
                     # Notify the last command it's superseded
                     previous_command.finished.set()

From f4d11b3c836b0a3bd8e5b828cd2e97b84f3246c7 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 16:53:03 +0000
Subject: [PATCH 20/30] Simplify JogCommand class structure, and remove
 unneeded event logic

---
 .../things/stage/__init__.py                  | 62 ++++---------------
 tests/unit_tests/test_stage.py                |  6 +-
 2 files changed, 16 insertions(+), 52 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index 74a43429..b2587678 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -33,40 +33,22 @@ class RedefinedBaseMovementError(RuntimeError):
 
 
 class JogCommand:
-    """A base class for jog operations.
+    """A base class for jog operations."""
 
-    This class handles threading events used to interrupt previous jog commands. There
-    are two subclasses that are used by jogging `JogMoveCommand` and `JogStopCommand`.
-    """
+    def __init__(self, displacement: Optional[Sequence[int]]) -> None:
+        """Initialise a JogCommand.
 
-    def __init__(self) -> None:
-        """Initialise a JogCommand."""
-        super().__init__()
-        self.finished = threading.Event()
-
-    def __repr__(self) -> str:
-        """Represent the command as a string."""
-        return f"<{self.__class__.__name__}>"
-
-
-class JogMoveCommand(JogCommand):
-    """A command to make a jog move."""
-
-    def __init__(self, displacement: Sequence[int]) -> None:
-        """Initialise a JogMoveCommand.
-
-        :param displacement: The displacement for the jog move, in hardware coordinates.
+        :param displacement: The distances as a sequence of the move for each axis.
+            None for stop motion.
         """
         super().__init__()
         self.displacement = displacement
 
     def __repr__(self) -> str:
         """Represent the command as a string."""
-        return f"<{self.__class__.__name__} {self.displacement}>"
-
-
-class JogStopCommand(JogCommand):
-    """A command to stop a jog move."""
+        if self.displacement is None:
+            return "<JogCommand>STOP"
+        return f"<JogCommand>{self.displacement}"
 
 
 class JogQueue(queue.Queue[JogCommand]):
@@ -283,7 +265,7 @@ class BaseStage(lt.Thing):
         :param kwargs: Keyword arguments should be axis names.
         """
         if stop:
-            self._send_jog_command(JogStopCommand(), timeout=1)
+            self._send_jog_command(JogCommand(None))
         else:
             self._hardware_jog(**self._apply_axis_direction(kwargs))
 
@@ -299,14 +281,9 @@ class BaseStage(lt.Thing):
         :param kwargs: Keyword arguments should be axis names.
         """
         move = [kwargs.get(axis, 0) for axis in self.axis_names]
-        self._send_jog_command(
-            JogMoveCommand(move),
-            timeout=self._estimate_move_duration(move) + 1,
-        )
+        self._send_jog_command(JogCommand(move))
 
-    def _send_jog_command(
-        self, command: JogCommand, timeout: Optional[float] = None
-    ) -> None:
+    def _send_jog_command(self, command: JogCommand) -> None:
         """Send a jog command to the background jog thread.
 
         This function will start the background thread if it is not running.
@@ -315,8 +292,6 @@ class BaseStage(lt.Thing):
         function should never block for a long time.
 
         :param command: the jog command to send.
-        :param timeout: how long to wait for the command to be completed, or ``None``
-            to skip waiting.
         """
         if not self._jog_lock.acquire(timeout=0.1):
             self.logger.warning(
@@ -337,10 +312,6 @@ class BaseStage(lt.Thing):
                 self._jog_queue.put(command)
         finally:
             self._jog_lock.release()
-        # The final wait happens after releasing the lock: this allows jog moves to
-        # be interrupted.
-        if timeout is not None:
-            command.finished.wait(timeout)
 
     def _jog_loop(self, first_command: JogCommand) -> None:
         """Execute jog commands in a background thread.
@@ -350,25 +321,18 @@ class BaseStage(lt.Thing):
         """
         # Timeout for checking queue
         timeout = 0.1
-        previous_command: Optional[JogCommand] = None
         command: Optional[JogCommand] = first_command
 
         # prevent others using the stage while jogging.
         with self._hardware_lock:
             while command is not None:
-                if previous_command:
-                    # Notify the last command it's superseded
-                    previous_command.finished.set()
-                previous_command = command
-                if isinstance(command, JogMoveCommand):
+                if command.displacement is not None:
                     self._hardware_start_move_relative(command.displacement)
                     timeout = self._estimate_move_duration(command.displacement)
-                elif isinstance(command, JogStopCommand):
+                else:
                     self._hardware_stop()
                     # Next iteration, we will probably time out.
                     timeout = 0.1
-                else:
-                    raise RuntimeError(f"Unknown jog command: {command}")
                 self.update_position()
                 command = self._get_from_jog_queue(timeout)
 
diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 1b2025f5..3ffdbf72 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -12,7 +12,7 @@ from labthings_fastapi.testing import create_thing_without_server
 from openflexure_microscope_server.things.camera.simulation import SimulatedCamera
 from openflexure_microscope_server.things.stage import (
     BaseStage,
-    JogMoveCommand,
+    JogCommand,
     RedefinedBaseMovementError,
 )
 from openflexure_microscope_server.things.stage.dummy import DummyStage
@@ -307,10 +307,10 @@ def test_get_jog_from_queue_most_recent(dummy_stage):
     """Test that the jog queue gives the most recent Jog Command."""
     # Try to stack 4 moves in the queue, only 1 should be queued.
     for i in range(4):
-        dummy_stage._jog_queue.put(JogMoveCommand([i, i, i]))
+        dummy_stage._jog_queue.put(JogCommand([i, i, i]))
 
     command = dummy_stage._get_from_jog_queue(0.001)
-    assert isinstance(command, JogMoveCommand)
+    assert isinstance(command, JogCommand)
     # Should be the last one queued
     assert command.displacement == [3, 3, 3]
     # Nothing else is queued

From 7ed718cbaeb1f5172566d331c3c29099ec4e2805 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Fri, 13 Feb 2026 17:05:24 +0000
Subject: [PATCH 21/30] Estimate move duraction added to each stage class

---
 src/openflexure_microscope_server/things/stage/__init__.py  | 5 +++--
 src/openflexure_microscope_server/things/stage/dummy.py     | 6 ++++++
 .../things/stage/sangaboard.py                              | 6 ++++++
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index b2587678..d48722f5 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -249,8 +249,9 @@ class BaseStage(lt.Thing):
 
     def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
         """Calculate the expected duration of a move with the given displacement."""
-        max_displacement = max(abs(d) for d in displacement)
-        return max_displacement * 0.001  # This does not yet check the board's speed.
+        raise NotImplementedError(
+            "StageThings must define their own _estimate_move_duration"
+        )
 
     @lt.action
     def jog(self, stop: bool = False, **kwargs: int) -> None:
diff --git a/src/openflexure_microscope_server/things/stage/dummy.py b/src/openflexure_microscope_server/things/stage/dummy.py
index 51af444e..5b3ba463 100644
--- a/src/openflexure_microscope_server/things/stage/dummy.py
+++ b/src/openflexure_microscope_server/things/stage/dummy.py
@@ -131,6 +131,12 @@ class DummyStage(BaseStage):
             self.moving = moving
         return moving
 
+    def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
+        """Calculate the expected duration of a move with the given displacement."""
+        max_displacement = max(abs(d) for d in displacement)
+        # This does not yet check the board's speed.
+        return max_displacement * self.step_time
+
     def _hardware_move_relative(
         self,
         block_cancellation: bool = False,
diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index e17df882..7107fed5 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -137,6 +137,12 @@ class SangaboardThing(BaseStage):
                 self.moving = moving
             return moving
 
+    def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
+        """Calculate the expected duration of a move with the given displacement."""
+        max_displacement = max(abs(d) for d in displacement)
+        # This does not yet check the board's speed.
+        return max_displacement * 0.001
+
     def _hardware_move_relative(
         self,
         block_cancellation: bool = False,

From 10f73cfb76dfd0a33c15b12d0734b5319c12e2e3 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 17:46:47 +0000
Subject: [PATCH 22/30] Read Sangaboard step time from board

---
 .../things/stage/sangaboard.py                             | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/openflexure_microscope_server/things/stage/sangaboard.py b/src/openflexure_microscope_server/things/stage/sangaboard.py
index 7107fed5..2c6e2be1 100644
--- a/src/openflexure_microscope_server/things/stage/sangaboard.py
+++ b/src/openflexure_microscope_server/things/stage/sangaboard.py
@@ -47,6 +47,8 @@ class SangaboardThing(BaseStage):
         """
         self.sangaboard_kwargs = copy(kwargs)
         self.sangaboard_kwargs["port"] = port
+        # Set a default step time, before reading on enter.
+        self._step_time = 0.001
 
         super().__init__(thing_server_interface, **kwargs)
 
@@ -55,8 +57,11 @@ class SangaboardThing(BaseStage):
         self._sangaboard = sangaboard.Sangaboard(**self.sangaboard_kwargs)
         with self._hardware_lock:
             self._sangaboard.query("blocking_moves false")
+            # Read step time only on enter as there is no provision for changing speed.
+            self._step_time = self._sangaboard.step_time * 1e-6
         self.check_firmware()
         self.update_position()
+
         return self
 
     def __exit__(
@@ -141,7 +146,7 @@ class SangaboardThing(BaseStage):
         """Calculate the expected duration of a move with the given displacement."""
         max_displacement = max(abs(d) for d in displacement)
         # This does not yet check the board's speed.
-        return max_displacement * 0.001
+        return max_displacement * self._step_time
 
     def _hardware_move_relative(
         self,

From 8a77c093058dc3264d9258ee555a1238a6d19275 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 21:37:05 +0000
Subject: [PATCH 23/30] Add some basic tests for base stage implementation

---
 .../things/stage/__init__.py                  | 13 ++++----
 tests/shared_utils/__init__.py                |  9 +++++
 tests/unit_tests/test_stage.py                | 33 ++++++++++++++++++-
 3 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index d48722f5..f7c58d0e 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -42,13 +42,14 @@ class JogCommand:
             None for stop motion.
         """
         super().__init__()
-        self.displacement = displacement
+        self.displacement = None if displacement is None else tuple(displacement)
 
     def __repr__(self) -> str:
         """Represent the command as a string."""
+        class_name = type(self).__name__
         if self.displacement is None:
-            return "<JogCommand>STOP"
-        return f"<JogCommand>{self.displacement}"
+            return f"<{class_name}>STOP"
+        return f"<{class_name}>{self.displacement}"
 
 
 class JogQueue(queue.Queue[JogCommand]):
@@ -227,13 +228,13 @@ class BaseStage(lt.Thing):
         Make sure to use and update ``self._hardware_position`` not ``self.position``.
         """
         raise NotImplementedError(
-            "StageThings must define their own move_absolute method"
+            "StageThings must define their own _hardware_move_absolute method"
         )
 
     def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
         """Start a relative move."""
         raise NotImplementedError(
-            "StageThings must define their own hardware_start_move_relative method"
+            "StageThings must define their own _hardware_start_move_relative method"
         )
 
     def _hardware_stop(self) -> None:
@@ -250,7 +251,7 @@ class BaseStage(lt.Thing):
     def _estimate_move_duration(self, displacement: Sequence[int]) -> float:
         """Calculate the expected duration of a move with the given displacement."""
         raise NotImplementedError(
-            "StageThings must define their own _estimate_move_duration"
+            "StageThings must define their own _estimate_move_duration method"
         )
 
     @lt.action
diff --git a/tests/shared_utils/__init__.py b/tests/shared_utils/__init__.py
index f0a5ab00..dda3b725 100644
--- a/tests/shared_utils/__init__.py
+++ b/tests/shared_utils/__init__.py
@@ -1 +1,10 @@
 """Shared utilities for all test suites."""
+
+import functools
+
+
+def get_method_name(method):
+    """Reliably get a methods name even if wrapped."""
+    while isinstance(method, functools.partial):
+        method = method.func
+    return getattr(method, "__name__", type(method).__name__)
diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 3ffdbf72..552b1b39 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -17,6 +17,7 @@ from openflexure_microscope_server.things.stage import (
 )
 from openflexure_microscope_server.things.stage.dummy import DummyStage
 
+from ..shared_utils import get_method_name
 from ..shared_utils.lt_test_utils import LabThingsTestEnv
 
 # Keep the size and number of moves fairly small or the tests can take forever
@@ -35,6 +36,26 @@ def dummy_stage():
     return create_thing_without_server(DummyStage, step_time=0.000001)
 
 
+def test_not_implemented_methods():
+    """Check all methods a child class should implement raise NotImplemented."""
+    stage = create_thing_without_server(BaseStage)
+    methods_and_args = [
+        (stage.update_position, ()),
+        (stage._hardware_move_relative, ()),
+        (stage._hardware_move_absolute, ()),
+        (stage._hardware_start_move_relative, ((1, 2, 3),)),
+        (stage._hardware_stop, ()),
+        (stage._poll_moving, ()),
+        (stage._estimate_move_duration, ((1, 2, 3),)),
+        (stage.set_zero_position, ()),
+    ]
+    for method, args in methods_and_args:
+        method_name = get_method_name(method)
+        msg = f"StageThings must define their own {method_name} method"
+        with pytest.raises(NotImplementedError, match=msg):
+            method(*args)
+
+
 def test_override_base_movement():
     """Child classes of stage should implement functions in the hardware reference frame.
 
@@ -303,6 +324,16 @@ def test_thing_description_equivalence(dummy_stage, mocker):
     assert sanga_properties == dummy_properties == base_properties
 
 
+def test_job_repr():
+    """Test when printing a jog command the result is as expected."""
+    # Jog should represent itself the same whether displacement is set with a list or a
+    # tuple.
+    assert str(JogCommand([1, 2, 3])) == "<JogCommand>(1, 2, 3)"
+    assert str(JogCommand((1, 2, 3))) == "<JogCommand>(1, 2, 3)"
+    # Stop should be very clear.
+    assert str(JogCommand(None)) == "<JogCommand>STOP"
+
+
 def test_get_jog_from_queue_most_recent(dummy_stage):
     """Test that the jog queue gives the most recent Jog Command."""
     # Try to stack 4 moves in the queue, only 1 should be queued.
@@ -312,6 +343,6 @@ def test_get_jog_from_queue_most_recent(dummy_stage):
     command = dummy_stage._get_from_jog_queue(0.001)
     assert isinstance(command, JogCommand)
     # Should be the last one queued
-    assert command.displacement == [3, 3, 3]
+    assert command.displacement == (3, 3, 3)
     # Nothing else is queued
     assert dummy_stage._get_from_jog_queue(0.001) is None

From 96ff243239e46415e203da4748b4ffa7d8027980 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 21:38:34 +0000
Subject: [PATCH 24/30] Remove an  method from BaseStage that is not hardware
 specific

---
 .../things/stage/__init__.py                  | 27 ++++++++-----------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index f7c58d0e..1f47d92b 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -268,22 +268,17 @@ class BaseStage(lt.Thing):
         """
         if stop:
             self._send_jog_command(JogCommand(None))
+            return
+
+        hardware_moves = self._apply_axis_direction(kwargs)
+        move = [hardware_moves.get(axis, 0) for axis in self.axis_names]
+        if all(ax == 0 for ax in move):
+            self.logger.warning(
+                "Requested jog movement is is empty. Sending STOP instead."
+            )
+            self._send_jog_command(JogCommand(None))
         else:
-            self._hardware_jog(**self._apply_axis_direction(kwargs))
-
-    def _hardware_jog(self, **kwargs: int) -> None:
-        """Make a relative move that may be interrupted by a future ``jog``.
-
-        This function uses hardware coordinates, ``jog`` is the public wrapper that
-        applies any neecessary transform and then calls this function. See the
-        docs for that function for more explanation.
-
-        See `_jog_loop` for an explanation of the mechanism.
-
-        :param kwargs: Keyword arguments should be axis names.
-        """
-        move = [kwargs.get(axis, 0) for axis in self.axis_names]
-        self._send_jog_command(JogCommand(move))
+            self._send_jog_command(JogCommand(move))
 
     def _send_jog_command(self, command: JogCommand) -> None:
         """Send a jog command to the background jog thread.
@@ -304,7 +299,7 @@ class BaseStage(lt.Thing):
             # Make sure the queue exists.
             # Check the background thread is running, and restart it if not.
             if self._jog_thread is None or not self._jog_thread.is_alive():
-                self.logger.info("Starting background thread for jog commands")
+                self.logger.debug("Starting background thread for jog commands")
                 self._jog_queue = JogQueue()
                 self._jog_thread = threading.Thread(
                     target=self._jog_loop, args=(command,)

From b4c2a7271a3212f19bea583796cb22d7801dbd90 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 22:17:35 +0000
Subject: [PATCH 25/30] Add tests for jog() action.

---
 tests/unit_tests/test_stage.py | 37 ++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 552b1b39..e18ab354 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -1,6 +1,7 @@
 """Test the stage without creating a full HTTP server and socket connection."""
 
 import itertools
+import logging
 
 import pytest
 from hypothesis import HealthCheck, given, settings
@@ -334,6 +335,42 @@ def test_job_repr():
     assert str(JogCommand(None)) == "<JogCommand>STOP"
 
 
+def test_empty_jog_sends_stop(dummy_stage, mocker, caplog):
+    """Check that calling ``jog`` with no args, warns then sends STOP."""
+    mock_send = mocker.patch.object(dummy_stage, "_send_jog_command")
+    with caplog.at_level(logging.WARNING):
+        dummy_stage.jog()
+    # This should warn as stop should be sent explicitly
+    assert len(caplog.records) == 1
+    assert mock_send.call_count == 1
+    # Check it is a stop command (displacement is None)
+    assert mock_send.call_args.args[0].displacement is None
+
+
+def test_jog_commands_are_sent(dummy_stage, mocker, caplog):
+    """Check that ``jog`` forwards commands to ``_send_jog_command``."""
+    mock_send = mocker.patch.object(dummy_stage, "_send_jog_command")
+    with caplog.at_level(logging.INFO):
+        dummy_stage.jog(x=1, y=0, z=0)
+        dummy_stage.jog(x=0, y=2, z=0)
+        dummy_stage.jog(x=0, y=0, z=3)
+        dummy_stage.jog(stop=True)
+    # Normal jogging operation shouldn't be filling up the logs.
+    assert len(caplog.records) == 0
+    # All 4 commands sent
+    assert mock_send.call_count == 4
+    # Check commands are as expected
+    command_0 = mock_send.call_args_list[0].args[0]
+    # -1 as axis inversion is applied
+    assert command_0.displacement == (-1, 0, 0)
+    command_1 = mock_send.call_args_list[1].args[0]
+    assert command_1.displacement == (0, 2, 0)
+    command_2 = mock_send.call_args_list[2].args[0]
+    assert command_2.displacement == (0, 0, 3)
+    command_3 = mock_send.call_args_list[3].args[0]
+    assert command_3.displacement is None
+
+
 def test_get_jog_from_queue_most_recent(dummy_stage):
     """Test that the jog queue gives the most recent Jog Command."""
     # Try to stack 4 moves in the queue, only 1 should be queued.

From 22994bdf9b7c1fa2ef9198ccf23054a1e5296627 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 22:56:55 +0000
Subject: [PATCH 26/30] A test for _send_jog_command

---
 tests/unit_tests/test_stage.py | 85 ++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index e18ab354..8b034043 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -371,6 +371,91 @@ def test_jog_commands_are_sent(dummy_stage, mocker, caplog):
     assert command_3.displacement is None
 
 
+def test_send_jog_commands(dummy_stage, mocker, caplog):
+    """Check that the jog command acts as expected."""
+
+    # Create a way to make mock threads.
+    def mock_thread_factory(*_args, **_kwargs):
+        """Return a mock thread instance that claims to be alive."""
+        mock_instance = mocker.Mock()
+        mock_instance.is_alive.return_value = True
+        return mock_instance
+
+    # Mock both the Queue class and threading.Thread to incercept calls.
+    mock_queue = mocker.patch(
+        "openflexure_microscope_server.things.stage.JogQueue", side_effect=mocker.Mock
+    )
+    mock_thread = mocker.patch(
+        "openflexure_microscope_server.things.stage.threading.Thread",
+        side_effect=mock_thread_factory,
+    )
+
+    commands = [
+        JogCommand([1, 1, 1]),
+        JogCommand([2, 2, 2]),
+        JogCommand([3, 3, 3]),
+        JogCommand([4, 4, 4]),
+    ]
+    # First call, will create a new thread and a new queue
+    dummy_stage._send_jog_command(commands[0])
+
+    # Both a new queue and a new thread are created
+    assert mock_queue.call_count == 1
+    assert mock_thread.call_count == 1
+    # The thread target is the jog loop
+    assert mock_thread.call_args.kwargs["target"] == dummy_stage._jog_loop
+    # Args are jut the first command
+    thread_args = mock_thread.call_args.kwargs["args"]
+    assert len(thread_args) == 1
+    assert thread_args[0] is commands[0]
+    # Nothing yet put in the thread
+    assert dummy_stage._jog_queue.put.call_count == 0
+
+    # Send second command:
+    dummy_stage._send_jog_command(commands[1])
+
+    # No new queue or thread created
+    assert mock_queue.call_count == 1
+    assert mock_thread.call_count == 1
+    # Put is used instead
+    assert dummy_stage._jog_queue.put.call_count == 1
+    # Called with the second command
+    assert dummy_stage._jog_queue.put.call_args.args[0] is commands[1]
+
+    # Make it so the thread has finished
+    dummy_stage._jog_thread.is_alive.return_value = False
+    assert not dummy_stage._jog_thread.is_alive()
+
+    # 3rd call call, will create a new thread and a new queue
+    dummy_stage._send_jog_command(commands[2])
+
+    # Thread is alive again
+    assert dummy_stage._jog_thread.is_alive()
+    # Both a new queue and a new thread are created
+    assert mock_queue.call_count == 2
+    assert mock_thread.call_count == 2
+    # The thread target is the jog loop
+    assert mock_thread.call_args.kwargs["target"] == dummy_stage._jog_loop
+    # Args are jut the first command
+    thread_args = mock_thread.call_args.kwargs["args"]
+    assert len(thread_args) == 1
+    assert thread_args[0] is commands[2]
+    # New queue is never used
+    assert dummy_stage._jog_queue.put.call_count == 0
+
+    # Finally acquire the jog lock
+    with dummy_stage._jog_lock:
+        # and check a warning is thrown
+        with caplog.at_level(logging.WARNING):
+            dummy_stage._send_jog_command(commands[3])
+        assert len(caplog.records) == 1
+        # No new thread or queue created
+        assert mock_queue.call_count == 2
+        assert mock_thread.call_count == 2
+        # And still nothing added to the queue
+        assert dummy_stage._jog_queue.put.call_count == 0
+
+
 def test_get_jog_from_queue_most_recent(dummy_stage):
     """Test that the jog queue gives the most recent Jog Command."""
     # Try to stack 4 moves in the queue, only 1 should be queued.

From 075667767178b31e3970f9dfcfae1672ce9e517d Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Mon, 16 Feb 2026 23:35:13 +0000
Subject: [PATCH 27/30] Test the jogging loop itself

---
 tests/unit_tests/test_stage.py | 78 ++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)

diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 8b034043..3b7e0a78 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -2,6 +2,8 @@
 
 import itertools
 import logging
+import threading
+import time
 
 import pytest
 from hypothesis import HealthCheck, given, settings
@@ -14,6 +16,7 @@ from openflexure_microscope_server.things.camera.simulation import SimulatedCame
 from openflexure_microscope_server.things.stage import (
     BaseStage,
     JogCommand,
+    JogQueue,
     RedefinedBaseMovementError,
 )
 from openflexure_microscope_server.things.stage.dummy import DummyStage
@@ -468,3 +471,78 @@ def test_get_jog_from_queue_most_recent(dummy_stage):
     assert command.displacement == (3, 3, 3)
     # Nothing else is queued
     assert dummy_stage._get_from_jog_queue(0.001) is None
+
+
+def _setup_jog_loop(command, dummy_stage, mocker):
+    """Set up a jog loop in a thread and return.
+
+    :return: The thread, and the mocks for ``_hardware_start_move_relative``,
+        ``_hardware_stop``, and ``_poll_moving``.
+    """
+    mocker.patch.object(dummy_stage, "_estimate_move_duration", return_value=0.01)
+    mock_poll = mocker.patch.object(dummy_stage, "_poll_moving", return_value=True)
+
+    def stop_mock_move(*_args, **_kwargs):
+        """Set the return value of poll to false on stop."""
+        mock_poll.return_value = False
+
+    mock_move = mocker.patch.object(dummy_stage, "_hardware_start_move_relative")
+    mock_stop = mocker.patch.object(
+        dummy_stage, "_hardware_stop", side_effect=stop_mock_move
+    )
+
+    dummy_stage._jog_queue = JogQueue()
+    thread = threading.Thread(target=dummy_stage._jog_loop, args=(command,))
+    thread.start()
+    return thread, mock_move, mock_stop, mock_poll
+
+
+def test_jog_loop_jog_once_only(dummy_stage, mocker):
+    """Check if jogging once the jog loops breaks when the move ends.
+
+    This checks there is no need for an explicit stop command.
+    """
+    command = JogCommand([1, 1, 0])
+    thread, mock_move, mock_stop, mock_poll = _setup_jog_loop(
+        command, dummy_stage, mocker
+    )
+    time.sleep(0.05)
+    assert thread.is_alive()
+    # Move was called
+    assert mock_move.call_count == 1
+    # Claim the motors have stopped
+    mock_poll.return_value = False
+    # Wait longer than 0.1s
+    time.sleep(0.15)
+    assert not thread.is_alive()
+    # Move never called again
+    assert mock_move.call_count == 1
+    # Stop never called.
+    assert mock_stop.call_count == 0
+
+
+def test_jog_loop_jog_twice_then_stop(dummy_stage, mocker):
+    """Check if jogging twice then calling stop."""
+    command = JogCommand([1, 0, 0])
+    command2 = JogCommand([2, 0, 0])
+    command3 = JogCommand(None)
+    thread, mock_move, mock_stop, mock_poll = _setup_jog_loop(
+        command, dummy_stage, mocker
+    )
+    time.sleep(0.05)
+    assert thread.is_alive()
+    # Move was called
+    assert mock_move.call_count == 1
+    assert mock_stop.call_count == 0
+
+    dummy_stage._jog_queue.put(command2)
+    time.sleep(0.05)
+    assert thread.is_alive()
+    assert mock_move.call_count == 2
+    assert mock_stop.call_count == 0
+
+    dummy_stage._jog_queue.put(command3)
+    time.sleep(0.15)
+    assert not thread.is_alive()
+    assert mock_move.call_count == 2
+    assert mock_stop.call_count == 1

From 56f68db5cae7b08812409c6829356d7ae7961795 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Tue, 17 Feb 2026 02:04:43 +0000
Subject: [PATCH 28/30] Move all dummy stage movement into a thread

---
 .../things/stage/__init__.py                  |   2 +-
 .../things/stage/dummy.py                     | 177 +++++++++++-------
 tests/unit_tests/test_stage.py                |  45 +++--
 3 files changed, 133 insertions(+), 91 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index 1f47d92b..7d92854c 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -100,7 +100,7 @@ class BaseStage(lt.Thing):
         self._jog_lock = threading.Lock()
         self._jog_queue = JogQueue()
         self._jog_thread: Optional[threading.Thread] = None
-        self._hardware_position = dict.fromkeys(self._axis_names, 0)
+        self._hardware_position: Mapping[str, int] = dict.fromkeys(self._axis_names, 0)
 
         # This must be the last thing the function does in case it is caught in a try.
         if (
diff --git a/src/openflexure_microscope_server/things/stage/dummy.py b/src/openflexure_microscope_server/things/stage/dummy.py
index 5b3ba463..a73bd724 100644
--- a/src/openflexure_microscope_server/things/stage/dummy.py
+++ b/src/openflexure_microscope_server/things/stage/dummy.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import queue
 import threading
 import time
 from collections.abc import Sequence
@@ -13,6 +14,18 @@ import labthings_fastapi as lt
 from . import BaseStage
 
 
+class DummyStageMovement:
+    """A class used internally to send movements to the dummy stages movement thread."""
+
+    def __init__(self, displacement: Optional[Sequence[int]]) -> None:
+        """Initialise with a displacement.
+
+        :param displacement: A sequence of integers or None to stop the motion.
+        """
+        self.started = threading.Event()
+        self.displacement = displacement
+
+
 class DummyStage(BaseStage):
     """A dummy stage for testing purposes.
 
@@ -34,15 +47,22 @@ class DummyStage(BaseStage):
             also doing computationally heavy tasks like simulated image blurring.
         """
         super().__init__(thing_server_interface, **kwargs)
+        self._movement_enabled = False
         self._move_thread: Optional[threading.Thread] = None
+        self._move_queue = queue.Queue[DummyStageMovement]()
+        self._movement_ongoing = False
+
         self.step_time = step_time
         self.instantaneous_position: Mapping[str, int] = self._hardware_position
         self._inst_pos_lock = threading.Lock()
         self._abort_move = threading.Event()
 
     def __enter__(self) -> Self:
-        """Register the stage position when the Thing context manager is opened."""
+        """Register the stage position and start move thread running."""
         self.instantaneous_position = self._hardware_position
+        self._movement_enabled = True
+        self._move_thread = threading.Thread(target=self._move_loop)
+        self._move_thread.start()
         return self
 
     def __exit__(
@@ -51,7 +71,10 @@ class DummyStage(BaseStage):
         _exc_value: Optional[BaseException],
         _traceback: Optional[TracebackType],
     ) -> None:
-        """Nothing to do when the Thing context manager is closed."""
+        """Stop the move thread."""
+        if self._move_thread is not None and self._move_thread.is_alive():
+            self._movement_enabled = False
+            self._move_thread.join()
 
     axis_inverted: dict[str, bool] = lt.setting(
         default={"x": True, "y": False, "z": False}, readonly=True
@@ -62,45 +85,73 @@ class DummyStage(BaseStage):
         """Read position from the stage and set the corresponding property."""
         pass
 
-    def _calc_fractional_pos(
+    def _set_pos_during_move(
         self, displacement: Sequence[int], fraction_complete: float
-    ) -> dict[str, int]:
-        """Calculate the position a fraction through a move."""
-        return {
+    ) -> None:
+        """Set the instantaneous position from the fraction through a move.
+
+        If this is the final set, also update hardware position
+        """
+        self.instantaneous_position = {
             ax: self._hardware_position[ax] + int(fraction_complete * disp)
             for ax, disp in zip(self.axis_names, displacement, strict=True)
         }
 
-    def _apply_move(self, displacement: Sequence[int]) -> None:
-        """Make a move, this function is designed to be run in a thread by jogging.
+    def _move_loop(self) -> None:
+        """Run the move loop. This should be run in a thread on enter.
 
-        This can't be used for normal movements as the delays setting up the extra
-        threads causes autofucs to fail. As such `_hardware_move_relative` is similarly
-        structured.
-
-        Interrupt this function with the ``self._abort_move`` event.
-
-        :param displacement: The (x, y, z) position.
+        This controls all movement of the dummy stage.
         """
+        # Start with no move request
+        movement_request: Optional[DummyStageMovement] = None
+        # Loop until the server ends.
+        while self._movement_enabled:
+            # First check for a new movement request. These will interrupt ongoing moves
+            movement_request = self._check_for_new_move_request()
+
+            # If there is a new movement.
+            if movement_request is not None:
+                # Set the hardware position from instantaneous before continuing.
+                self._hardware_position = self.instantaneous_position
+
+                if movement_request.displacement is None:
+                    # If it is a stop command, stop moving
+                    self._movement_ongoing = False
+                    movement_request.started.set()
+                else:
+                    # Record the displacement for future iterations
+                    displacement = movement_request.displacement
+                    # If it is a move command, set up the variables for the move
+                    self._movement_ongoing = True
+                    movement_request.started.set()
+                    fraction_complete = 0.0
+                    dt = self.step_time
+                    max_displacement = max(abs(v) for v in displacement)
+                    # Always wait at least dt
+                    total_time = max((dt * max_displacement), dt)
+                    start_time = time.time()
+                    time.sleep(dt)
+
+            # If a movement is ongoing
+            if self._movement_ongoing:
+                fraction_complete = (time.time() - start_time) / total_time
+                if fraction_complete < 1:
+                    self._set_pos_during_move(displacement, fraction_complete)
+                else:
+                    # move is complete
+                    fraction_complete = 1.0
+                    self._set_pos_during_move(displacement, fraction_complete)
+                    self._hardware_position = self.instantaneous_position
+                    self._movement_ongoing = False
+
+    def _check_for_new_move_request(self) -> Optional[DummyStageMovement]:
+        """Check for new move request to the move_loop."""
         try:
-            fraction_complete = 0.0
-            dt = self.step_time
-            max_displacement = max(abs(v) for v in displacement)
-            start_time = time.time()
-            while time.time() - start_time < dt * max_displacement:
-                if self._abort_move.is_set():
-                    break
-                fraction_complete = (time.time() - start_time) / (dt * max_displacement)
-                self.instantaneous_position = self._calc_fractional_pos(
-                    displacement, fraction_complete
-                )
-            if not self._abort_move.is_set():
-                fraction_complete = 1.0
-        finally:
-            self._hardware_position = self._calc_fractional_pos(
-                displacement, fraction_complete
-            )
-            self.instantaneous_position = self._hardware_position
+            # Timeout sets the motor speed time
+            timeout = self.step_time * 10 if self._movement_ongoing else 0.1
+            return self._move_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
 
     def _hardware_start_move_relative(self, displacement: Sequence[int]) -> None:
         """Start a relative move.
@@ -111,22 +162,16 @@ class DummyStage(BaseStage):
         """
         with self._hardware_lock:
             self.moving = True
-            self._abort_move.clear()
-            self._move_thread = threading.Thread(
-                target=self._apply_move, args=(displacement,)
-            )
-            self._move_thread.start()
+            self._move_queue.put(DummyStageMovement(displacement))
 
     def _hardware_stop(self) -> None:
         with self._hardware_lock:
-            self._abort_move.set()
+            self._move_queue.put(DummyStageMovement(None))
             self.moving = False
 
     def _poll_moving(self) -> bool:
         """Determine if the stage is still moving."""
-        if self._move_thread is None:
-            return False
-        moving = self._move_thread.is_alive()
+        moving = self._movement_ongoing
         if self.moving != moving:
             self.moving = moving
         return moving
@@ -146,38 +191,26 @@ class DummyStage(BaseStage):
         with self._hardware_lock:
             displacement = [kwargs.get(k, 0) for k in self.axis_names]
             self.moving = True
-            # This follows a similar structure to _apply_move but need a different
-            # breakning mechanism. Running apply move in a thread and breaking here
-            # results in significantly worse autofocus
-            try:
-                fraction_complete = 0.0
-                dt = self.step_time
-                max_displacement = max(abs(v) for v in displacement)
-                start_time = time.time()
-                while time.time() - start_time < dt * max_displacement:
+            move_request = DummyStageMovement(displacement)
+            self._move_queue.put(move_request)
+
+            move_request.started.wait(timeout=0.1)
+            while self._movement_ongoing:
+                try:
                     if block_cancellation:
-                        time.sleep(self.step_time)
+                        time.sleep(self.step_time * 10)
                     else:
-                        lt.cancellable_sleep(self.step_time)
-                    fraction_complete = (time.time() - start_time) / (
-                        dt * max_displacement
-                    )
-                    self.instantaneous_position = self._calc_fractional_pos(
-                        displacement, fraction_complete
-                    )
-                fraction_complete = 1.0
-            except lt.exceptions.InvocationCancelledError as e:
-                # If the move has been cancelled, stop it but don't handle the
-                # exception. We need the exception to propagate in order to stop
-                # any calling tasks, and to mark the invocation as "cancelled"
-                # rather than stopped.
-                raise e
-            finally:
-                self._hardware_position = self._calc_fractional_pos(
-                    displacement, fraction_complete
-                )
-                self.instantaneous_position = self._hardware_position
-                self.moving = False
+                        lt.cancellable_sleep(self.step_time * 10)
+
+                except lt.exceptions.InvocationCancelledError as e:
+                    # If the move has been cancelled, stop it but don't handle the
+                    # exception. We need the exception to propagate in order to stop
+                    # any calling tasks, and to mark the invocation as "cancelled"
+                    # rather than stopped.
+                    self._move_queue.put(DummyStageMovement(None))
+                    raise e
+                finally:
+                    self.moving = False
 
     def _hardware_move_absolute(
         self,
diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index 3b7e0a78..a22a1171 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -37,7 +37,7 @@ path3d = st.lists(point3d, min_size=5, max_size=10)
 @pytest.fixture
 def dummy_stage():
     """Return a dummy stage with a very low step time."""
-    return create_thing_without_server(DummyStage, step_time=0.000001)
+    return create_thing_without_server(DummyStage, step_time=0.0001)
 
 
 def test_not_implemented_methods():
@@ -206,15 +206,20 @@ def _test_move_relative(dummy_stage, axis_inverted, path):
     y_dir = -1 if axis_inverted["y"] else 1
     z_dir = -1 if axis_inverted["z"] else 1
 
-    position = list(dummy_stage.position.values())
-    for movement in path:
-        dummy_stage.move_relative(x=movement[0], y=movement[1], z=movement[2])
-        position = [pos + move for pos, move in zip(position, movement, strict=True)]
-        stage_pos = dummy_stage.get_xyz_position()
-        hw_pos = dummy_stage._hardware_position
-        assert position[0] == stage_pos[0] == hw_pos["x"] * x_dir
-        assert position[1] == stage_pos[1] == hw_pos["y"] * y_dir
-        assert position[2] == stage_pos[2] == hw_pos["z"] * z_dir
+    # Enter the stage to start the movement thread.
+    with dummy_stage:
+        assert dummy_stage._move_thread.is_alive()
+        position = list(dummy_stage.position.values())
+        for movement in path:
+            dummy_stage.move_relative(x=movement[0], y=movement[1], z=movement[2])
+            position = [
+                pos + move for pos, move in zip(position, movement, strict=True)
+            ]
+            stage_pos = dummy_stage.get_xyz_position()
+            hw_pos = dummy_stage._hardware_position
+            assert position[0] == stage_pos[0] == hw_pos["x"] * x_dir
+            assert position[1] == stage_pos[1] == hw_pos["y"] * y_dir
+            assert position[2] == stage_pos[2] == hw_pos["z"] * z_dir
 
 
 @given(path=path3d)
@@ -260,14 +265,18 @@ def _test_move_absolute(dummy_stage, axis_inverted, path):
     y_dir = -1 if axis_inverted["y"] else 1
     z_dir = -1 if axis_inverted["z"] else 1
     position = list(dummy_stage.position.values())
-    for move_to in path:
-        dummy_stage.move_absolute(x=move_to[0], y=move_to[1], z=move_to[2])
-        position = move_to
-        stage_pos = dummy_stage.get_xyz_position()
-        hw_pos = dummy_stage._hardware_position
-        assert position[0] == stage_pos[0] == hw_pos["x"] * x_dir
-        assert position[1] == stage_pos[1] == hw_pos["y"] * y_dir
-        assert position[2] == stage_pos[2] == hw_pos["z"] * z_dir
+
+    # Enter the stage to start the movement thread.
+    with dummy_stage:
+        assert dummy_stage._move_thread.is_alive()
+        for move_to in path:
+            dummy_stage.move_absolute(x=move_to[0], y=move_to[1], z=move_to[2])
+            position = move_to
+            stage_pos = dummy_stage.get_xyz_position()
+            hw_pos = dummy_stage._hardware_position
+            assert position[0] == stage_pos[0] == hw_pos["x"] * x_dir
+            assert position[1] == stage_pos[1] == hw_pos["y"] * y_dir
+            assert position[2] == stage_pos[2] == hw_pos["z"] * z_dir
 
 
 @given(path=path3d)

From ea3de5f45d268baa509adcbab1de973adc8a32d1 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Tue, 17 Feb 2026 17:56:26 +0000
Subject: [PATCH 29/30] Apply suggestions from code review of branch jogging

Co-authored-by: Joe Knapper <joe.knapper@glasgow.ac.uk>
---
 src/openflexure_microscope_server/things/stage/__init__.py | 4 ++--
 src/openflexure_microscope_server/things/stage/dummy.py    | 5 +----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/openflexure_microscope_server/things/stage/__init__.py b/src/openflexure_microscope_server/things/stage/__init__.py
index 7d92854c..2c06eaf3 100644
--- a/src/openflexure_microscope_server/things/stage/__init__.py
+++ b/src/openflexure_microscope_server/things/stage/__init__.py
@@ -38,7 +38,7 @@ class JogCommand:
     def __init__(self, displacement: Optional[Sequence[int]]) -> None:
         """Initialise a JogCommand.
 
-        :param displacement: The distances as a sequence of the move for each axis.
+        :param displacement: The distances as a sequence of moves for each axis.
             None for stop motion.
         """
         super().__init__()
@@ -347,7 +347,7 @@ class BaseStage(lt.Thing):
                 if not self._poll_moving():
                     # The stage is no longer moving, return None
                     return None
-            # If we reached here then the stage is still moving shorten timeout and
+            # If we reached here then the stage is still moving. Shorten timeout and
             # check again.
             timeout = 0.1
 
diff --git a/src/openflexure_microscope_server/things/stage/dummy.py b/src/openflexure_microscope_server/things/stage/dummy.py
index a73bd724..3b1aaf0a 100644
--- a/src/openflexure_microscope_server/things/stage/dummy.py
+++ b/src/openflexure_microscope_server/things/stage/dummy.py
@@ -88,10 +88,7 @@ class DummyStage(BaseStage):
     def _set_pos_during_move(
         self, displacement: Sequence[int], fraction_complete: float
     ) -> None:
-        """Set the instantaneous position from the fraction through a move.
-
-        If this is the final set, also update hardware position
-        """
+        """Set the instantaneous position based on the completed fraction of an ongoing move."""
         self.instantaneous_position = {
             ax: self._hardware_position[ax] + int(fraction_complete * disp)
             for ax, disp in zip(self.axis_names, displacement, strict=True)

From d9deb1a7e79737a78dfd5bbecee2b04f1365bc99 Mon Sep 17 00:00:00 2001
From: Julian Stirling <julian@julianstirling.co.uk>
Date: Wed, 18 Feb 2026 13:44:29 +0000
Subject: [PATCH 30/30] Typos and clarity fixes from review of jogging branch

Co-authored-by: Joe Knapper <joe.knapper@glasgow.ac.uk>
---
 tests/unit_tests/test_stage.py                      | 13 ++++++++-----
 webapp/src/App.vue                                  |  4 ++--
 .../controlComponents/positionControl.vue           |  1 -
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/tests/unit_tests/test_stage.py b/tests/unit_tests/test_stage.py
index a22a1171..727f4c4d 100644
--- a/tests/unit_tests/test_stage.py
+++ b/tests/unit_tests/test_stage.py
@@ -337,8 +337,11 @@ def test_thing_description_equivalence(dummy_stage, mocker):
     assert sanga_properties == dummy_properties == base_properties
 
 
-def test_job_repr():
-    """Test when printing a jog command the result is as expected."""
+def test_jog_command_repr():
+    """Test when printing a jog command the result is as expected.
+
+    This tests the ``__repr__`` method of ``JogCommand``.
+    """
     # Jog should represent itself the same whether displacement is set with a list or a
     # tuple.
     assert str(JogCommand([1, 2, 3])) == "<JogCommand>(1, 2, 3)"
@@ -416,7 +419,7 @@ def test_send_jog_commands(dummy_stage, mocker, caplog):
     assert mock_thread.call_count == 1
     # The thread target is the jog loop
     assert mock_thread.call_args.kwargs["target"] == dummy_stage._jog_loop
-    # Args are jut the first command
+    # Args are just the first command
     thread_args = mock_thread.call_args.kwargs["args"]
     assert len(thread_args) == 1
     assert thread_args[0] is commands[0]
@@ -438,7 +441,7 @@ def test_send_jog_commands(dummy_stage, mocker, caplog):
     dummy_stage._jog_thread.is_alive.return_value = False
     assert not dummy_stage._jog_thread.is_alive()
 
-    # 3rd call call, will create a new thread and a new queue
+    # call with the 3rd command, will create a new thread and a new queue
     dummy_stage._send_jog_command(commands[2])
 
     # Thread is alive again
@@ -448,7 +451,7 @@ def test_send_jog_commands(dummy_stage, mocker, caplog):
     assert mock_thread.call_count == 2
     # The thread target is the jog loop
     assert mock_thread.call_args.kwargs["target"] == dummy_stage._jog_loop
-    # Args are jut the first command
+    # Args are just the first command
     thread_args = mock_thread.call_args.kwargs["args"]
     assert len(thread_args) == 1
     assert thread_args[0] is commands[2]
diff --git a/webapp/src/App.vue b/webapp/src/App.vue
index 671e3d39..67fe4ebc 100644
--- a/webapp/src/App.vue
+++ b/webapp/src/App.vue
@@ -267,12 +267,12 @@ export default {
      * Jog for key-presses.
      *
      * This is a similar to the function in stageControlButtons.vue however it uses
-     * uses the key repeat to fire in case a key up is missed. It debounes any
+     * uses the key repeat to fire in case a key up is missed. It debounces any
      * request to jog that is too recent after the last jog.
      */
     jog(x, y, z) {
       // Manually debounce extra requests from keyboard repeat rate.
-      // This is used rather than and interval in case of missing a repeat.
+      // This is used rather than an interval in case of missing a repeat.
       const now = Date.now();
       const navigationInvert = this.$store.state.navigationInvert;
       if (now - this.lastJogTime < this.jogTime) {
diff --git a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
index dda20aeb..f6db90db 100644
--- a/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
+++ b/webapp/src/components/tabContentComponents/controlComponents/positionControl.vue
@@ -93,7 +93,6 @@ export default {
     eventBus.on("globalUpdatePositionEvent", this.updatePosition);
     // A global signal listener to perform a move action in pixels
     eventBus.on("globalMoveInImageCoordinatesEvent", this.onMoveImage);
-    // A global signal listener to perform a move in multiples of a step size
 
     // Update the current position in text boxes
     await this.updatePosition();