pyrpoc 0.1.0__tar.gz

pyrpoc-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025, Ishaan Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pyrpoc-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: pyrpoc
+Version: 0.1.0
+Summary: Real-time Precision Opto-Control Toolkit
+Author-email: Ishaan Singh <sing1125@purdue.com>
+License: Copyright 2025, Ishaan Singh
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: matplotlib
+Requires-Dist: pyqt5
+Requires-Dist: superqt
+Requires-Dist: cellpose
+Requires-Dist: nidaqmx
+Requires-Dist: pyvisa
+Dynamic: license-file
+
+# pyrpoc
+
+Author: Ishaan Singh, Zhang Group (https://sites.google.com/view/zhangresearchgroup)
+
+## Basic Installation
+
+Navigate to the directory that contains ```setup.py```. Run 
+
+``` 
+pip install -e .
+```
+
+Please reach out to sing1125@purdue.edu with any suggestions or feedback on the GUI. 

pyrpoc-0.1.0/README.md

@@ -0,0 +1,13 @@
+# pyrpoc
+
+Author: Ishaan Singh, Zhang Group (https://sites.google.com/view/zhangresearchgroup)
+
+## Basic Installation
+
+Navigate to the directory that contains ```setup.py```. Run 
+
+``` 
+pip install -e .
+```
+
+Please reach out to sing1125@purdue.edu with any suggestions or feedback on the GUI. 

pyrpoc-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "pyrpoc"
+version = "0.1.0"
+description = "Real-time Precision Opto-Control Toolkit"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { file = "LICENSE" }
+
+authors = [
+  { name = "Ishaan Singh", email = "sing1125@purdue.com" }
+]
+
+dependencies = [
+  "numpy",
+  "scipy",
+  "opencv-python",
+  "pillow",
+  "matplotlib",
+  "pyqt5",       
+  "superqt",     
+  "cellpose",      
+  "nidaqmx",   
+  "pyvisa",      
+  # Add any others your app depends on
+]
+
+[project.scripts]
+pyrpoc = "pyrpoc.main:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

pyrpoc-0.1.0/pyrpoc/helpers/calibration.py

@@ -0,0 +1,125 @@
+import tkinter as tk
+from tkinter import ttk, messagebox
+import time, threading
+from matplotlib.figure import Figure
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+from pyrpoc.helpers.galvo_funcs import Galvo
+from pyrpoc.helpers.run_image_2d import run_scan  
+from pyrpoc.helpers.utils import generate_data
+
+# TODO: make the calibration plot dark mode because pretty
+def calibrate_stage(gui):
+    cal_win = tk.Toplevel(gui.root)
+    cal_win.title("Stage Calibration")
+    cal_win.geometry("900x600")
+
+    config_frame = ttk.Frame(cal_win, padding=10)
+    config_frame.pack(side=tk.TOP, fill=tk.X)
+
+    ttk.Label(config_frame, text='Start Position (µm)').grid(row=0, column=0, sticky='w', padx=5, pady=3)
+    start_entry = ttk.Entry(config_frame, width=12, font=('Calibri', 14))
+    start_entry.insert(0, str(gui.hyper_config['start_um']))
+    start_entry.grid(row=0, column=1, padx=5, pady=3)
+
+    ttk.Label(config_frame, text='Stop Position (µm)').grid(row=1, column=0, sticky='w', padx=5, pady=3)
+    stop_entry = ttk.Entry(config_frame, width=12, font=('Calibri', 14))
+    stop_entry.insert(0, str(gui.hyper_config['stop_um']))
+    stop_entry.grid(row=1, column=1, padx=5, pady=3)
+
+    ttk.Label(config_frame, text='Number of Steps').grid(row=2, column=0, sticky='w', padx=5, pady=3)
+    cal_steps_entry = ttk.Entry(config_frame, width=10, font=('Calibri', 14))
+    cal_steps_entry.insert(0, '10')
+    cal_steps_entry.grid(row=2, column=1, padx=5, pady=3)
+
+    start_button = ttk.Button(config_frame, text='Start Calibration')
+    start_button.grid(row=3, column=0, columnspan=2, padx=5, pady=10)
+
+    fig = Figure(figsize=(5, 3), dpi=100)
+    ax = fig.add_subplot(111)
+    ax.set_title('Calibration Data')
+    ax.set_xlabel('Stage Position (µm)')
+    ax.set_ylabel('Average Intensity')
+
+    canvas = FigureCanvasTkAgg(fig, master=cal_win)
+    canvas_widget = canvas.get_tk_widget()
+    canvas_widget.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+
+    cal_running = [False]
+
+    def run_calibration():
+        cal_running[0] = True
+        try:
+            start_val = float(start_entry.get().strip())
+            stop_val = float(stop_entry.get().strip())
+            n_steps = int(cal_steps_entry.get().strip())
+            if n_steps < 1 or start_val >= stop_val:
+                raise ValueError
+        except ValueError:
+            messagebox.showerror("Error", "Invalid calibration settings.")
+            cal_running[0] = False
+            return
+
+        try:
+            gui.zaber_stage.connect()
+        except Exception as e:
+            messagebox.showerror("Zaber Error", str(e))
+            cal_running[0] = False
+            return
+
+        positions_to_scan = ([start_val]
+            if n_steps == 1 else
+            [start_val + i * (stop_val - start_val) / (n_steps - 1)
+             for i in range(n_steps)]
+        )
+
+        positions, intensities = [], []
+
+        for pos in positions_to_scan:
+            if not cal_running[0]:
+                break
+            try:
+                gui.zaber_stage.move_absolute_um(pos)
+            except Exception as e:
+                messagebox.showerror("Zaber Error", str(e))
+                cal_running[0] = False
+                break
+
+            # TODO: calibration can still acquire simulation - probably good to display a warning about that though
+            if gui.simulation_mode.get():
+                data_list = generate_data(len(gui.config['ai_chans']), config=gui.config)
+                data = data_list[0]
+            else:
+                galvo = Galvo(gui.config)
+                data_list = raster_scan(
+                    [f"{gui.config['device']}/{ch}" for ch in gui.config['ai_chans']], 
+                    galvo
+                )
+                data = data_list[0]
+
+            avg_val = data.mean()
+            positions.append(pos)
+            intensities.append(avg_val)
+
+            ax.clear()
+            ax.set_title('Calibration Data')
+            ax.set_xlabel('Stage Position (µm)')
+            ax.set_ylabel('Average Intensity')
+            ax.plot(positions, intensities, '-o', color='blue')
+            canvas.draw()
+            canvas.flush_events()
+
+            time.sleep(0.2)
+
+        cal_running[0] = False
+
+    def start_cal():
+        if not cal_running[0]:
+            threading.Thread(target=run_calibration, daemon=True).start()
+
+    start_button.configure(command=start_cal) 
+
+    stop_button = ttk.Button(
+        config_frame, text='Stop Calibration',
+        command=lambda: cal_running.__setitem__(0, False)
+    )
+    stop_button.grid(row=4, column=0, columnspan=2, padx=5, pady=5)

pyrpoc-0.1.0/pyrpoc/helpers/galvo_funcs.py

@@ -0,0 +1,136 @@
+import nidaqmx
+from nidaqmx.constants import AcquisitionType
+import numpy as np
+from PIL import Image
+from tkinter import messagebox
+
+class Galvo:
+    def __init__(self, config, rpoc_mask=None, rpoc_do_chan=None, rpoc_mode=None, dwell_multiplier=2.0, **kwargs):
+        defaults = {
+            "numsteps_x": 400,
+            "numsteps_y": 400,
+            "extrasteps_left": 50,
+            "extrasteps_right": 50,
+            "offset_x": 0.0,
+            "offset_y": 0.0,
+            "dwell": 10e-6,
+            "amp_x": 0.5,
+            "amp_y": 0.5,
+            "rate": 10000,
+            "device": 'Dev1',
+            "ao_chans": ['ao1', 'ao0']
+        }
+        if config:
+            defaults.update(config)
+        defaults.update(kwargs)
+        for key, val in defaults.items():
+            setattr(self, key, val)
+
+        self.rpoc_mask = rpoc_mask
+        self.rpoc_do_chan = rpoc_do_chan
+        self.rpoc_mode = rpoc_mode  # "standard" or "variable" so far
+        self.dwell_multiplier = dwell_multiplier
+
+        self.pixel_samples = max(1, int(self.dwell * self.rate))
+        self.total_x = self.numsteps_x + self.extrasteps_left + self.extrasteps_right
+        self.total_y = self.numsteps_y
+        self.total_samples = self.total_x * self.total_y * self.pixel_samples
+
+        if self.rpoc_mode == "variable":
+            self.waveform = None  # or maybe generate it here...
+        else:
+            self.waveform = self.gen_raster()
+
+    def gen_raster(self):
+        total_rowsamples = self.pixel_samples * self.total_x
+        self.total_samples = total_rowsamples * self.total_y
+
+        single_row_ramp = np.linspace(
+            self.offset_x - self.amp_x,
+            self.offset_x + self.amp_x,
+            total_rowsamples,
+            endpoint=False
+        )
+        x_waveform = np.tile(single_row_ramp, self.total_y)
+
+        y_steps = np.linspace(
+            self.offset_y + self.amp_y,
+            self.offset_y - self.amp_y,
+            self.total_y
+        )
+        y_waveform = np.repeat(y_steps, total_rowsamples)
+
+        composite = np.vstack([x_waveform, y_waveform])
+
+        if self.rpoc_mask is not None and self.rpoc_do_chan is not None:
+            rpoc_wave = build_rpoc_wave(
+                self.rpoc_mask,
+                self.pixel_samples,
+                self.total_x,
+                self.total_y,
+                high_voltage=5.0
+            )
+            if rpoc_wave.size != y_waveform.size:
+                raise ValueError("RPOC wave length does not match total scan length!")
+            composite = np.vstack([composite, rpoc_wave])
+
+        if x_waveform.size < self.total_samples:
+            x_waveform = np.pad(
+                x_waveform,
+                (0, self.total_samples - x_waveform.size),
+                constant_values=x_waveform[-1]
+            )
+        else:
+            x_waveform = x_waveform[:self.total_samples]
+        composite[0] = x_waveform
+
+        return composite
+
+
+    def gen_variable_waveform(self, mask, dwell_multiplier):
+        dwell = self.dwell
+        rate = self.rate
+        num_y = self.numsteps_y
+        num_x = self.numsteps_x + self.extrasteps_left + self.extrasteps_right
+
+        mask_shape = np.shape(mask)
+        if mask_shape[1] != num_y or mask_shape[0] != (num_x - self.extrasteps_left - self.extrasteps_right):
+            raise ValueError(f'Error in galvo_funcs.gen_variable_waveform(). Mask is not the right size. Load a mask of dimensions {num_x - self.extrasteps_left - self.extrasteps_right} by {num_y}.')
+
+
+        dwell_on = dwell * dwell_multiplier
+        dwell_off = dwell
+
+
+        x_min = self.offset_x - self.amp_x
+        x_max = self.offset_x + self.amp_x
+        x_positions = np.linspace(x_min, x_max, num_x, endpoint=False)
+        y_positions = np.linspace(self.offset_y + self.amp_y,
+                                self.offset_y - self.amp_y,
+                                num_y)
+
+        x_wave_list = []
+        y_wave_list = []
+        pixel_map = np.zeros((num_y, num_x), dtype=int)
+
+        for row_idx in range(num_y):
+            row_y = y_positions[row_idx]
+            for col_idx in range(num_x):
+                if col_idx < self.extrasteps_left or col_idx >= (num_x - self.extrasteps_right): # for clarity im leaving this out of the else - we need to remember to account for extrasteps here
+                    this_dwell = dwell_off
+                elif mask[row_idx, col_idx - self.extrasteps_left]:
+                    this_dwell = dwell_on
+                else:
+                    this_dwell = dwell_off
+
+                pixel_samps = max(1, int(this_dwell * rate))
+
+                x_val = x_positions[col_idx]
+                x_wave_list.append(np.full(pixel_samps, x_val))
+
+                y_wave_list.append(np.full(pixel_samps, row_y))
+
+                pixel_map[row_idx, col_idx] = pixel_samps
+        x_wave = np.concatenate(x_wave_list)
+        y_wave = np.concatenate(y_wave_list)
+        return x_wave, y_wave, pixel_map

pyrpoc-0.1.0/pyrpoc/helpers/prior_stage/functions.py

@@ -0,0 +1,176 @@
+from ctypes import WinDLL, create_string_buffer
+import os
+import time
+import numpy as np
+from pyrpoc.mains import acquisition
+import cv2
+
+DLL_PATH = os.path.join(os.path.dirname(__file__), "PriorScientificSDK.dll")
+SDKPrior = None
+sessionID = None 
+_prior_connected = False  # Track connection state
+
+
+def connect_prior(port=4):
+    global _prior_connected
+    if _prior_connected:
+        return
+
+    ret, _ = send_command(f"controller.connect {port}")
+    if ret == 0:
+        _prior_connected = True
+        print(f"Connected to Prior stage on COM{port}")
+    else:
+        raise RuntimeError(f"Failed to connect to Prior stage on COM{port}")
+
+
+def initialize_sdk():
+    global SDKPrior, sessionID
+
+    if SDKPrior is None:
+        if os.path.exists(DLL_PATH):
+            SDKPrior = WinDLL(DLL_PATH)
+        else:
+            raise RuntimeError("DLL could not be loaded.")
+
+        ret = SDKPrior.PriorScientificSDK_Initialise()  
+        if ret != 0:
+            raise RuntimeError(f"Failed to initialize Prior SDK. Error code: {ret}")
+
+        print("Prior SDK Initialized.")
+
+    if sessionID is None:
+        sessionID = SDKPrior.PriorScientificSDK_OpenNewSession()
+        if sessionID < 0:
+            raise RuntimeError(f"Failed to open Prior SDK session. SessionID: {sessionID}")
+
+        print(f"SDK Session Opened. Session ID: {sessionID}")
+
+
+def send_command(command):
+    initialize_sdk()
+
+    rx = create_string_buffer(1000)
+    ret = SDKPrior.PriorScientificSDK_cmd(
+        sessionID, create_string_buffer(command.encode()), rx
+    )
+    response = rx.value.decode().strip()
+
+    if ret != 0:
+        print(f"Error executing command: {command} (Return Code: {ret})")
+
+    return ret, response
+
+
+def wait_for_z_motion():
+    while True:
+        _, response = send_command("controller.z.busy.get")
+
+        if response:
+            try:
+                status = int(response)
+                if status == 0:
+                    break  
+            except ValueError:
+                print(f"Invalid response from controller: '{response}'")
+        else:
+            print("No response from controller, is it connected?")
+
+        time.sleep(0.1)
+
+def auto_focus(gui, port: int, channel_name: str, step_size=10):
+    connect_prior(port)
+
+    gui.simulation_mode.set(False)
+    gui.acquiring = True
+
+    try:
+        channel_index = gui.config["channel_names"].index(channel_name)
+    except ValueError:
+        raise RuntimeError(f"Invalid channel name: '{channel_name}'")
+
+    ret, current_z = send_command("controller.z.position.get")
+    if ret != 0:
+        raise RuntimeError("Failed to retrieve current Z position.")
+    try:
+        current_z = int(current_z)
+    except ValueError:
+        raise RuntimeError(f"Invalid Z position response: '{current_z}'")
+
+    z_positions = [current_z + i * step_size for i in range(-10, 11)]  # total of 21 points
+    best_focus = -1
+    best_z = current_z
+
+    gui.progress_label.config(text=f'(0/{len(z_positions)})')
+    gui.root.update_idletasks()
+
+    for i, z in enumerate(z_positions):
+        if not gui.acquiring:
+            print("[Autofocus] Interrupted by Stop.")
+            break
+
+        try:
+            send_command(f"controller.z.goto-position {z}")
+            wait_for_z_motion()
+        except Exception as e:
+            gui.acquiring = False
+            raise RuntimeError(f"Stage move to Z={z} failed: {e}")
+
+        acquisition.acquire(gui, auxilary=True)
+        gui.root.update_idletasks()
+        gui.root.update()
+
+        image = gui.data[channel_index]
+        x, y = np.shape(image)
+        metric = cv2.Laplacian(image[int(3*x/8):int(5*x/8), int(3*y/8):int(5*y/8)], cv2.CV_64F).var() # only use the middle eighth for focus
+        print(f"Z={z} → Focus Metric={metric:.2f}")
+
+        if metric > best_focus:
+            best_focus = metric
+            best_z = z
+
+        gui.progress_label.config(text=f'({i + 1}/{len(z_positions)})')
+        gui.root.update_idletasks()
+
+    if gui.acquiring:
+        send_command(f"controller.z.goto-position {best_z}")
+        wait_for_z_motion()
+
+        acquisition.acquire(gui, auxilary=True)
+        gui.root.update_idletasks()
+        gui.root.update()
+        print(f"[Autofocus] Best Z = {best_z}, Metric = {best_focus:.2f}")
+
+    gui.acquiring = False
+    return best_z, best_focus
+
+
+def move_z(port: int, z_height: int):
+    connect_prior(port)
+
+    if not (0 <= z_height <= 50000):
+        raise ValueError("Z height must be between 0 and 50,000 µm.")
+
+    ret, _ = send_command(f"controller.z.goto-position {z_height}")
+    if ret != 0:
+        raise RuntimeError(f"Could not move Prior stage to {z_height} µm.")
+    wait_for_z_motion()
+
+
+def move_xy(port: int, x: int, y: int):
+    connect_prior(port)
+
+    if not (0 <= x <= 50000) or not (0 <= y <= 50000):
+        raise ValueError("X and Y positions must be between 0 and 50,000 µm.")
+
+    ret, _ = send_command(f"controller.stage.goto-position {x} {y}")
+    if ret != 0:
+        raise RuntimeError(f"Could not move Prior stage to {x}, {y}.")
+
+
+if __name__ == "__main__":
+    print("connecting")
+    connect_prior(4)
+
+    move_xy(4, 1000, 1000)
+    move_z(4, 2500)

pyrpoc-0.1.0/pyrpoc/helpers/prior_stage/prior_interface.py

@@ -0,0 +1,129 @@
+# Created by Diego Alonso Alvarez on the 12th July 2020
+#
+# Copyright (c) 2020 Imperial College London
+#
+#Permission is hereby granted, free of charge, to any person obtaining a copy
+#of this software and associated documentation files (the "Software"), to deal
+#in the Software without restriction, including without limitation the rights
+#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#copies of the Software, and to permit persons to whom the Software is
+#furnished to do so, subject to the following conditions:
+#
+#The above copyright notice and this permission notice shall be included in all
+#copies or substantial portions of the Software.
+#
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#SOFTWARE.
+
+from ctypes import WinDLL, create_string_buffer
+import os
+import sys
+
+path = r"C:\Users\Lab Admin\Documents\PythonStuff\pysrs\pysrs\instruments\prior_stage\PriorScientificSDK.dll"
+
+if os.path.exists(path):
+    SDKPrior = WinDLL(path)
+else:
+    raise RuntimeError("DLL could not be loaded.")
+
+rx = create_string_buffer(1000)
+realhw = True
+
+
+def cmd(msg):
+    print(msg)
+    ret = SDKPrior.PriorScientificSDK_cmd(
+        sessionID, create_string_buffer(msg.encode()), rx
+    )
+    if ret:
+        print(f"Api error {ret}")
+    else:
+        print(f"46 OK {rx.value.decode()}")
+
+    input("48 Press ENTER to continue...")
+    return ret, rx.value.decode()
+
+
+ret = SDKPrior.PriorScientificSDK_Initialise()
+if ret:
+    print(f"54 Error initialising {ret}")
+    sys.exit()
+else:
+    print(f"57 Ok initialising {ret}")
+
+
+ret = SDKPrior.PriorScientificSDK_Version(rx)
+print(f"61 dll version api ret={ret}, version={rx.value.decode()}")
+
+
+sessionID = SDKPrior.PriorScientificSDK_OpenNewSession()
+if sessionID < 0:
+    print(f"66 Error getting sessionID {ret}")
+else:
+    print(f"68 SessionID = {sessionID}")
+
+
+ret = SDKPrior.PriorScientificSDK_cmd(
+    sessionID, create_string_buffer(b"72 dll.apitest 33 goodresponse"), rx
+)
+print(f"74 api response {ret}, rx = {rx.value.decode()}")
+input("75 Press ENTER to continue...")
+
+
+ret = SDKPrior.PriorScientificSDK_cmd(
+    sessionID, create_string_buffer(b"dll.apitest -300 stillgoodresponse"), rx
+)
+print(f"81 api response {ret}, rx = {rx.value.decode()}")
+input("82 Press ENTER to continue...")
+
+
+if realhw:
+    print("Connecting...")
+    # substitute 3 with your com port Id
+    cmd("controller.connect 4")
+
+    # test an illegal command
+    cmd("controller.stage.position.getx")
+
+    # get current XY position in default units of microns
+    cmd("controller.stage.position.get")
+
+    # re-define this current position as 1234,5678
+    cmd("controller.stage.position.set 1234 5678")
+
+    # check it worked
+    cmd("controller.stage.position.get")
+
+    # set it back to 0,0
+    cmd("controller.stage.position.set 0 0")
+    cmd("controller.stage.position.get")
+
+    # start a move to a new position, normally you would poll
+    # 'controller.stage.busy.get' until response = 0
+    cmd("controller.stage.goto-position 1234 5678")
+
+    # example velocity move of 10u/s in both x and y
+    cmd("controller.stage.move-at-velocity 10 10")
+
+    # see busy status
+    cmd("controller.stage.busy.get")
+
+    # stop velocity move
+    cmd("controller.stage.move-at-velocity 0 0")
+
+    # see busy status */
+    cmd("controller.stage.busy.get")
+
+    # see new position
+    cmd("controller.stage.position.get")
+
+    # disconnect cleanly from controller
+    cmd("controller.disconnect")
+
+else:
+    input("Press ENTER to continue...")