fixed doc typo, removed temp benchmarking from controller.

Author: MichaelPhilbin

catkit2/services/physik_stage_controller/physik_stage_controller.py

@@ -1,6 +1,5 @@
 import numpy as np
 import threading
-import time
 from catkit2.testbed.service import Service
 from pipython import GCSDevice, pitools
 
@@ -126,89 +125,19 @@ def _submit_positions(self):
 
     def _target_positions_worker(self):
         """Worker thread to handle move_to commands from the target_positions data stream."""
-        # Benchmarking variables
-        iteration_count = 0
-        benchmark_start = time.perf_counter()
-        total_mov_time = 0.0
-        # total_mutex_wait_time = 0.0
-        last_frame_time = None
-        frame_intervals = []
-
         while not self.should_shut_down:
             try:
                 frame = self.target_positions.get_next_frame(wait_time_in_ms=250)
-                loop_start = time.perf_counter()
-
-                # Track time between frames
-                if last_frame_time is not None:
-                    frame_intervals.append(loop_start - last_frame_time)
-                last_frame_time = loop_start
-
                 data = frame.data
-
                 positions = {
                     self.axis_num_to_name[num]: float(data[idx])
                     for idx, num in enumerate(sorted(self.axis_map.values()))
                 }
-
-                # Benchmark move_to (includes mutex acquisition and MOV command)
-                mov_start = time.perf_counter()
-                self._move_to_internal(positions, benchmark_times=True)
-                mov_end = time.perf_counter()
-                total_mov_time += (mov_end - mov_start)
-
-                iteration_count += 1
-
-                # Log benchmark every 500 iterations
-                if iteration_count % 500 == 0:
-                    elapsed = time.perf_counter() - benchmark_start
-                    avg_rate = iteration_count / elapsed
-                    avg_mov_time = (total_mov_time / iteration_count) * 1000  # ms
-
-                    if frame_intervals:
-                        avg_interval = (sum(frame_intervals) / len(frame_intervals)) * 1000  # ms
-                        min_interval = min(frame_intervals) * 1000
-                        max_interval = max(frame_intervals) * 1000
-                    else:
-                        avg_interval = min_interval = max_interval = 0
-
-                    self.log.info(
-                        f'[BENCHMARK] iterations={iteration_count}, '
-                        f'avg_rate={avg_rate:.1f} Hz, '
-                        f'avg_MOV={avg_mov_time:.2f}ms, '
-                        f'frame_interval: avg={avg_interval:.2f}ms min={min_interval:.2f}ms max={max_interval:.2f}ms'
-                    )
-
-                    # Reset for next window
-                    frame_intervals = []
-                    iteration_count = 0
-                    benchmark_start = time.perf_counter()
-                    total_mov_time = 0.0
-
+                self.move_to(positions)
                 self.sleep(0)
             except RuntimeError:
                 pass
 
-    def _move_to_internal(self, positions, benchmark_times=False):
-        """
-        Internal move_to used by worker thread with optional benchmarking.
-        Bypasses initialization check since worker only runs after init.
-        """
-        axis_positions = {}
-        for name, value in positions.items():
-            if name in self.axis_map:
-                axis_num = self.axis_map[name]
-                axis_positions[axis_num] = float(value)
-
-        if not axis_positions:
-            return
-
-        with self.mutex:
-            self.pidevice.MOV(axis_positions)
-
-        self.is_moving = True
-        self.move_event.set()
-
     def main(self):
         """Main loop - polls for move completion and updates telemetry when motion stops."""
         while not self.should_shut_down:

catkit2/services/physik_stage_controller_sim/physik_stage_controller_sim.py

@@ -38,7 +38,7 @@ def open(self):
         # Create data streams
         num_axes = len(self.axis_map)
         self.positions = self.make_data_stream('positions', 'float64', [num_axes], 20)
-        self.target_positions = self.make_data_stream('target_positions', 'float64', [num_axes], 20)
+        self.target_positions = self.make_data_stream('target_positions', 'float64', [num_axes], 1)
 
         # Precompute reverse map
         self.axis_num_to_name = {num: name for name, num in self.axis_map.items()}
@@ -126,6 +126,7 @@ def move_to(self, positions):
         """Move to absolute positions (instantaneous)."""
         if not self.is_initialized:
             raise RuntimeError("Controller not initialized")
+        self.log.info(f"Moving to positions: {positions}")
         axis_positions = {self.axis_map[name]: float(value) for name, value in positions.items() if name in self.axis_map}
         if axis_positions:
             with self.mutex:

docs/services/physik_stage_controller.rst

@@ -95,7 +95,7 @@ Commands
 
 .. code-block:: python
 
-  # Example of using get_positions by a command call
+  # Example of using stop_motion by a command call
   # stage is the service instance for the Physik stage controller
   stage.stop_motion()
   # Server Log:[physik_stage_controller] Motion stopped