micropsi-integration-sdk 0.24.0__tar.gz → 0.26.0__tar.gz

{micropsi-integration-sdk-0.24.0 → micropsi_integration_sdk-0.26.0}/PKG-INFO

@@ -1,19 +1,32 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: micropsi-integration-sdk
-Version: 0.24.0
+Version: 0.26.0
 Summary: Integration SDK for Micropsi Industries
 Home-page: https://github.com/micropsi-industries/micropsi-integration-sdk
 Author: Micropsi Industries
 Author-email: contact@micropsi-industries.com
 License: MIT
-Platform: macosx-14-arm64
-Requires-Python: >=3.6, <4
+Platform: macosx-15-arm64
+Requires-Python: >=3.10, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: pyquaternion
+Requires-Dist: scipy
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Micropsi Industries Integration SDK
 Package for implementing and testing robots to be integrated with Mirai.
@@ -50,50 +63,85 @@ hardware.
 They can be used as a starting point when developing a new robot implementation.
 
 ## Mirai sandbox
-Standalone tool to test the SDK-based Robot control implementation.
-Moves the robot and verifies the implementation of methods described in Robot SDK. In particular
-the implementation of the high-frequency control loop. 
-The direction (x, y or z axis) and length of the test movement can be configured.
-```bash
-usage: mirai-sandbox [-h] [-m MODEL] [-sl SPEED_LINEAR] [-sa SPEED_ANGULAR]
-                     [-d DIMENSION] [-l LENGTH] [-ip IP_ADDRESS]
-                     [-tl TOLERANCE_LINEAR] [-ta TOLERANCE_ANGULAR] [-v]
+Standalone tool to test an SDK-based robot interface implementation. This will attempt
+to read robot poses and send movement commands in ways similar to Mirai, helping to
+uncover problems related to geometry and real time control.
+
+If successful, the robot will go through a defined sequence of tool pose changes
+and return to its start pose. See `--help` or below for details.
+
+**CAUTION**
+This will attempt to move the robot. Although this tool (by default) only
+outputs low-speed commands, prepare for unexpected behavior including large,
+high-speed movements when testing with a newly written interface.
+
+```
+usage: mirai-sandbox [-h] [-m MODEL] [-ip IP_ADDRESS] [-sl SPEED_LINEAR] [-sa SPEED_ROTATION] [--test [{translations,single-rotations,chained-rotations} ...]] [--max-distance-translation MAX_DISTANCE_TRANSLATION]
+                     [--max-distance-degrees MAX_DISTANCE_DEGREES] [-tl TOLERANCE_LINEAR] [-ta TOLERANCE_ROTATION] [-v] [-d DIMENSION] [-l LENGTH]
                      path
 
-Micropsi Industries Robot SDK Tool
+This will attempt to read poses and execute movements on a given robot interface.
+
+Expected outcome: The robot moves through the following sequence of waypoints,
+and ends up back at the start pose:
+
+    # translations:
+    1. Translate in tool +X by a set amount, then -X by the same amount (= return to origin)
+    2. Similar for tool +/- Y
+    3. Similar for tool +/- Z
+    # single rotations:
+    4. Rotate around tool +X by a set amount, then -X (= return to origin)
+    5. Similar for tool +/- Y
+    6. Similar for tool +/- Z
+    7. Rotate around the tool XY diagonal, then return
+    8. Similar for the YZ diagonal
+    9. Similar for the XZ diagonal
+    # chained rotations:
+    10. Rotate around tool Z, then Y, then X; then return in the reverse order.
+
+See --help for config options (e.g. range of motion, speed, including/excluding some of the motions)
 
 positional arguments:
   path                  Path to the robot implementation
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
   -m MODEL, --model MODEL
                         Name of the robot model as defined in the implementation.
-  -sl SPEED_LINEAR, --speed-linear SPEED_LINEAR
-                        Linear end-effector speed, meters per second.
-                        Default: 0.05, Max: 0.1
-  -sa SPEED_ANGULAR, --speed-angular SPEED_ANGULAR
-                        Angular end-effector speed, radians per second.
-                        Default: 0.2617993877991494, Max: 0.6981317007977318
-  -d DIMENSION, --dimension DIMENSION
-                        Number of axes to move the robot in.
-                        Default: 1
-  -l LENGTH, --length LENGTH
-                        Length of test movement, meters.
-                        Default:0.05, Max: 0.1m
   -ip IP_ADDRESS, --ip-address IP_ADDRESS
                         IP address of the robot.
                         Default: 192.168.100.100
+  -sl SPEED_LINEAR, --speed-linear SPEED_LINEAR
+                        Linear end-effector speed, meters per second.
+                        Default: 0.05
+  -sa SPEED_ROTATION, --speed-rotation SPEED_ROTATION
+                        Rotational end-effector speed, degrees per second.
+                        Default: 5.0°
+  --test [{translations,single-rotations,chained-rotations} ...]
+                        Select which tests to run, can specify one or multiple.
+                        Choices: translations, single-rotations, chained-rotations.
+                        Default: run all.
+  --max-distance-translation MAX_DISTANCE_TRANSLATION
+                        Maximum distance for translational movements, meters.
+                        Default: 0.05
+  --max-distance-degrees MAX_DISTANCE_DEGREES
+                        Maximum distance for rotational movements, degrees.
+                        Default: 10.0°
   -tl TOLERANCE_LINEAR, --tolerance-linear TOLERANCE_LINEAR
-                        Linear tolerance of the end-effector position achieved by robot.
-                        Default: 0.001 meters
-  -ta TOLERANCE_ANGULAR, --tolerance-angular TOLERANCE_ANGULAR
-                        Angular tolerance of the end-effector position achieved by robot.
-                        Default: 0.01 radians
+                        Consider a position linearly reached when within this distance, meters
+                        Default: 0.001m
+  -ta TOLERANCE_ROTATION, --tolerance-rotation TOLERANCE_ROTATION
+                        Consider a position rotationally reached when within this distance, degrees
+                        Default: 0.5°
   -v, --verbose         Enable debug logging.
+  -d DIMENSION, --dimension DIMENSION
+                        OBSOLETE: See --test
+  -l LENGTH, --length LENGTH
+                        OBSOLETE: See --max-distance-translation and --max-distance-degrees
 
-Usage example: mirai-sandbox ./examples/cartesian_velocity_robot.py
+Usage example: mirai-sandbox ../examples/cartesian_velocity_robot.py
 ```
+
 ## Mirai dev server
 This tool simulates a mirai controller in certain (very simplified) ways.
 Once started, it listens on port 6599 for the commands sent by either your PLC or robot program,

micropsi-integration-sdk-0.24.0/micropsi_integration_sdk.egg-info/PKG-INFO → micropsi_integration_sdk-0.26.0/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.1
-Name: micropsi-integration-sdk
-Version: 0.24.0
-Summary: Integration SDK for Micropsi Industries
-Home-page: https://github.com/micropsi-industries/micropsi-integration-sdk
-Author: Micropsi Industries
-Author-email: contact@micropsi-industries.com
-License: MIT
-Platform: macosx-14-arm64
-Requires-Python: >=3.6, <4
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: numpy
-Requires-Dist: pyquaternion
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-
 # Micropsi Industries Integration SDK
 Package for implementing and testing robots to be integrated with Mirai.
 A brief introduction and command reference can be found here.
@@ -50,50 +33,85 @@ hardware.
 They can be used as a starting point when developing a new robot implementation.
 
 ## Mirai sandbox
-Standalone tool to test the SDK-based Robot control implementation.
-Moves the robot and verifies the implementation of methods described in Robot SDK. In particular
-the implementation of the high-frequency control loop. 
-The direction (x, y or z axis) and length of the test movement can be configured.
-```bash
-usage: mirai-sandbox [-h] [-m MODEL] [-sl SPEED_LINEAR] [-sa SPEED_ANGULAR]
-                     [-d DIMENSION] [-l LENGTH] [-ip IP_ADDRESS]
-                     [-tl TOLERANCE_LINEAR] [-ta TOLERANCE_ANGULAR] [-v]
+Standalone tool to test an SDK-based robot interface implementation. This will attempt
+to read robot poses and send movement commands in ways similar to Mirai, helping to
+uncover problems related to geometry and real time control.
+
+If successful, the robot will go through a defined sequence of tool pose changes
+and return to its start pose. See `--help` or below for details.
+
+**CAUTION**
+This will attempt to move the robot. Although this tool (by default) only
+outputs low-speed commands, prepare for unexpected behavior including large,
+high-speed movements when testing with a newly written interface.
+
+```
+usage: mirai-sandbox [-h] [-m MODEL] [-ip IP_ADDRESS] [-sl SPEED_LINEAR] [-sa SPEED_ROTATION] [--test [{translations,single-rotations,chained-rotations} ...]] [--max-distance-translation MAX_DISTANCE_TRANSLATION]
+                     [--max-distance-degrees MAX_DISTANCE_DEGREES] [-tl TOLERANCE_LINEAR] [-ta TOLERANCE_ROTATION] [-v] [-d DIMENSION] [-l LENGTH]
                      path
 
-Micropsi Industries Robot SDK Tool
+This will attempt to read poses and execute movements on a given robot interface.
+
+Expected outcome: The robot moves through the following sequence of waypoints,
+and ends up back at the start pose:
+
+    # translations:
+    1. Translate in tool +X by a set amount, then -X by the same amount (= return to origin)
+    2. Similar for tool +/- Y
+    3. Similar for tool +/- Z
+    # single rotations:
+    4. Rotate around tool +X by a set amount, then -X (= return to origin)
+    5. Similar for tool +/- Y
+    6. Similar for tool +/- Z
+    7. Rotate around the tool XY diagonal, then return
+    8. Similar for the YZ diagonal
+    9. Similar for the XZ diagonal
+    # chained rotations:
+    10. Rotate around tool Z, then Y, then X; then return in the reverse order.
+
+See --help for config options (e.g. range of motion, speed, including/excluding some of the motions)
 
 positional arguments:
   path                  Path to the robot implementation
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
   -m MODEL, --model MODEL
                         Name of the robot model as defined in the implementation.
-  -sl SPEED_LINEAR, --speed-linear SPEED_LINEAR
-                        Linear end-effector speed, meters per second.
-                        Default: 0.05, Max: 0.1
-  -sa SPEED_ANGULAR, --speed-angular SPEED_ANGULAR
-                        Angular end-effector speed, radians per second.
-                        Default: 0.2617993877991494, Max: 0.6981317007977318
-  -d DIMENSION, --dimension DIMENSION
-                        Number of axes to move the robot in.
-                        Default: 1
-  -l LENGTH, --length LENGTH
-                        Length of test movement, meters.
-                        Default:0.05, Max: 0.1m
   -ip IP_ADDRESS, --ip-address IP_ADDRESS
                         IP address of the robot.
                         Default: 192.168.100.100
+  -sl SPEED_LINEAR, --speed-linear SPEED_LINEAR
+                        Linear end-effector speed, meters per second.
+                        Default: 0.05
+  -sa SPEED_ROTATION, --speed-rotation SPEED_ROTATION
+                        Rotational end-effector speed, degrees per second.
+                        Default: 5.0°
+  --test [{translations,single-rotations,chained-rotations} ...]
+                        Select which tests to run, can specify one or multiple.
+                        Choices: translations, single-rotations, chained-rotations.
+                        Default: run all.
+  --max-distance-translation MAX_DISTANCE_TRANSLATION
+                        Maximum distance for translational movements, meters.
+                        Default: 0.05
+  --max-distance-degrees MAX_DISTANCE_DEGREES
+                        Maximum distance for rotational movements, degrees.
+                        Default: 10.0°
   -tl TOLERANCE_LINEAR, --tolerance-linear TOLERANCE_LINEAR
-                        Linear tolerance of the end-effector position achieved by robot.
-                        Default: 0.001 meters
-  -ta TOLERANCE_ANGULAR, --tolerance-angular TOLERANCE_ANGULAR
-                        Angular tolerance of the end-effector position achieved by robot.
-                        Default: 0.01 radians
+                        Consider a position linearly reached when within this distance, meters
+                        Default: 0.001m
+  -ta TOLERANCE_ROTATION, --tolerance-rotation TOLERANCE_ROTATION
+                        Consider a position rotationally reached when within this distance, degrees
+                        Default: 0.5°
   -v, --verbose         Enable debug logging.
+  -d DIMENSION, --dimension DIMENSION
+                        OBSOLETE: See --test
+  -l LENGTH, --length LENGTH
+                        OBSOLETE: See --max-distance-translation and --max-distance-degrees
 
-Usage example: mirai-sandbox ./examples/cartesian_velocity_robot.py
+Usage example: mirai-sandbox ../examples/cartesian_velocity_robot.py
 ```
+
 ## Mirai dev server
 This tool simulates a mirai controller in certain (very simplified) ways.
 Once started, it listens on port 6599 for the commands sent by either your PLC or robot program,
@@ -158,4 +176,4 @@ optional arguments:
 
 Usage example:
 # mirai-dev-client GetBoxMetadata
-```
+```

{micropsi-integration-sdk-0.24.0 → micropsi_integration_sdk-0.26.0}/examples/cartesian_pose_robot.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Optional
 
 import numpy as np
+from scipy.spatial.transform import Rotation
 
 from micropsi_integration_sdk import CartesianPoseRobot, HardwareState
 
@@ -14,20 +14,20 @@ class MyCartesianPoseRobot(CartesianPoseRobot):
         self.__connected = False
         self.__ready_for_control = False
         self.__controlled = False
-        self.__joint_positions = np.zeros(3)
+        self.__pose = np.eye(4)
 
     @staticmethod
     def get_supported_models() -> list:
         return ["MyRobot Cartesian Pose"]
 
     def get_joint_count(self) -> int:
-        return 3
+        return 6
 
-    def get_joint_speed_limits(self) -> np.array:
-        return np.array([.2, .2, .2])
+    def get_joint_speed_limits(self) -> np.ndarray:
+        return np.ones(6)
 
-    def get_joint_position_limits(self) -> np.array:
-        return np.array([[-.5, .5], [-.5, .5], [-.5, .5]])
+    def get_joint_position_limits(self) -> np.ndarray:
+        return np.array([[-1, 1]] * 6)
 
     def connect(self) -> bool:
         self.__connected = True
@@ -49,9 +49,10 @@ class MyCartesianPoseRobot(CartesianPoseRobot):
         self.__controlled = False
         self.__ready_for_control = False
 
-    def get_hardware_state(self) -> Optional[HardwareState]:
+    def get_hardware_state(self) -> HardwareState:
         state = HardwareState(
-            joint_positions=np.copy(self.__joint_positions),
+            joint_positions=self.inverse_kinematics(end_effector_pose=self.__pose),
+            end_effector_pose=np.copy(self.__pose),
         )
         LOG.debug("State: %s", state)
         return state
@@ -59,25 +60,36 @@ class MyCartesianPoseRobot(CartesianPoseRobot):
     def clear_cached_hardware_state(self) -> None:
         pass
 
-    def forward_kinematics(self, *, joint_positions: np.array) -> np.array:
-        matrix = np.identity(4)
-        matrix[:3, 3] = joint_positions
-        return matrix
+    def forward_kinematics(self, *, joint_positions: np.ndarray) -> np.ndarray:
+        # trivial mock kinematics
+        pose = np.eye(4)
+        pose[:3, 3] = joint_positions[:3]
+        pose[:3, :3] = Rotation.from_rotvec(joint_positions[3:6]).as_matrix()
+        return pose
+
+    def inverse_kinematics(self, *, end_effector_pose: np.ndarray,
+                           joint_reference=None) -> np.ndarray:
+        # trivial mock kinematics
+        position = end_effector_pose[:3, 3]
+        axis_angle = Rotation.from_matrix(end_effector_pose[:3, :3]).as_rotvec()
+        return np.concatenate([position, axis_angle])
 
     def send_goal_pose(self, *, goal_pose: np.ndarray, step_count: int) -> None:
         assert goal_pose.shape == (4, 4)
-        self.__joint_positions = goal_pose[:3, 3]
+        self.__pose = np.copy(goal_pose)
 
     def are_joint_positions_safe(self, *, joint_positions: np.ndarray) -> bool:
         limits = self.get_joint_position_limits()
-        for idx, joint_position in enumerate(joint_positions):
-            limit = limits[idx]
-            if not limit[0] < joint_position < limit[1]:
+        for idx, position in enumerate(joint_positions):
+            if not limits[idx][0] <= position <= limits[idx][1]:
                 return False
         return True
 
-    def command_move(self, *, joint_positions: np.array) -> None:
-        self.__joint_positions = np.copy(joint_positions)
+    def command_move(self, *, joint_positions: np.ndarray) -> None:
+        self.__pose = self.forward_kinematics(joint_positions=joint_positions)
 
     def command_stop(self) -> None:
         pass
+
+    def get_slowdown_steps_in_seconds(self) -> float:
+        return 0.05

micropsi_integration_sdk-0.26.0/examples/cartesian_velocity_robot.py

@@ -0,0 +1,98 @@
+import logging
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+from micropsi_integration_sdk import CartesianVelocityRobot, HardwareState
+
+LOG = logging.getLogger(__name__)
+
+
+class MyCartesianVelocityRobot(CartesianVelocityRobot):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.__connected = False
+        self.__ready_for_control = False
+        self.__controlled = False
+        self.__pose = np.eye(4)
+
+    @staticmethod
+    def get_supported_models() -> list:
+        return ["MyRobot Cartesian Velocity"]
+
+    def get_joint_count(self) -> int:
+        return 6
+
+    def get_joint_speed_limits(self) -> np.ndarray:
+        return np.ones(6)
+
+    def get_joint_position_limits(self) -> np.ndarray:
+        return np.array([[-1, 1]] * 6)
+
+    def connect(self) -> bool:
+        self.__connected = True
+        return True
+
+    def disconnect(self) -> None:
+        self.__connected = False
+
+    def prepare_for_control(self) -> None:
+        self.__ready_for_control = True
+
+    def is_ready_for_control(self) -> bool:
+        return self.__ready_for_control
+
+    def take_control(self) -> None:
+        self.__controlled = True
+
+    def release_control(self) -> None:
+        self.__controlled = False
+        self.__ready_for_control = False
+
+    def get_hardware_state(self) -> HardwareState:
+        state = HardwareState(
+            joint_positions=self.inverse_kinematics(end_effector_pose=self.__pose),
+            end_effector_pose=np.copy(self.__pose),
+        )
+        LOG.debug("State: %s", state)
+        return state
+
+    def clear_cached_hardware_state(self) -> None:
+        pass
+
+    def forward_kinematics(self, *, joint_positions: np.ndarray) -> np.ndarray:
+        # trivial mock kinematics
+        pose = np.eye(4)
+        pose[:3, 3] = joint_positions[:3]
+        pose[:3, :3] = Rotation.from_rotvec(joint_positions[3:6]).as_matrix()
+        return pose
+
+    def inverse_kinematics(self, *, end_effector_pose: np.ndarray,
+                           joint_reference=None) -> np.ndarray:
+        # trivial mock kinematics
+        position = end_effector_pose[:3, 3]
+        axis_angle = Rotation.from_matrix(end_effector_pose[:3, :3]).as_rotvec()
+        return np.concatenate([position, axis_angle])
+
+    def send_velocity(self, *, velocity: np.ndarray, step_count: int) -> None:
+        assert velocity.shape == (6,), velocity.shape
+        dt = 1.0 / self.get_frequency()
+        self.__pose[:3, 3] += velocity[:3] * dt
+        delta_R = Rotation.from_rotvec(velocity[3:6] * dt).as_matrix()
+        self.__pose[:3, :3] = delta_R @ self.__pose[:3, :3]
+
+    def are_joint_positions_safe(self, *, joint_positions: np.ndarray) -> bool:
+        limits = self.get_joint_position_limits()
+        for idx, position in enumerate(joint_positions):
+            if not limits[idx][0] <= position <= limits[idx][1]:
+                return False
+        return True
+
+    def command_move(self, *, joint_positions: np.ndarray) -> None:
+        self.__pose = self.forward_kinematics(joint_positions=joint_positions)
+
+    def command_stop(self) -> None:
+        pass
+
+    def get_slowdown_steps_in_seconds(self) -> float:
+        return 0.05

{micropsi-integration-sdk-0.24.0 → micropsi_integration_sdk-0.26.0}/examples/joint_position_robot.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Optional
 
 import numpy as np
+from scipy.spatial.transform import Rotation
 
 from micropsi_integration_sdk import JointPositionRobot, HardwareState
 
@@ -11,23 +11,23 @@ LOG = logging.getLogger(__name__)
 class MyJointPositionRobot(JointPositionRobot):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.__joint_positions = np.zeros(3)
         self.__connected = False
         self.__ready_for_control = False
         self.__controlled = False
+        self.__pose = np.eye(4)
 
     @staticmethod
     def get_supported_models() -> list:
         return ["MyRobot JointPosition"]
 
     def get_joint_count(self) -> int:
-        return 3
+        return 6
 
-    def get_joint_speed_limits(self) -> np.array:
-        return np.array([.2, .2, .2])
+    def get_joint_speed_limits(self) -> np.ndarray:
+        return np.ones(6)
 
-    def get_joint_position_limits(self) -> np.array:
-        return np.array([[-.5, .5], [-.5, .5], [-.5, .5]])
+    def get_joint_position_limits(self) -> np.ndarray:
+        return np.array([[-1, 1]] * 6)
 
     def connect(self) -> bool:
         self.__connected = True
@@ -49,9 +49,10 @@ class MyJointPositionRobot(JointPositionRobot):
         self.__controlled = False
         self.__ready_for_control = False
 
-    def get_hardware_state(self) -> Optional[HardwareState]:
+    def get_hardware_state(self) -> HardwareState:
         state = HardwareState(
-            joint_positions=np.copy(self.__joint_positions),
+            joint_positions=self.inverse_kinematics(end_effector_pose=self.__pose),
+            end_effector_pose=np.copy(self.__pose),
         )
         LOG.debug("State: %s", state)
         return state
@@ -59,27 +60,35 @@ class MyJointPositionRobot(JointPositionRobot):
     def clear_cached_hardware_state(self) -> None:
         pass
 
-    def forward_kinematics(self, *, joint_positions: np.array) -> np.array:
-        matrix = np.identity(4)
-        matrix[:3, 3] = joint_positions
-        return matrix
+    def forward_kinematics(self, *, joint_positions: np.ndarray) -> np.ndarray:
+        # trivial mock kinematics
+        pose = np.eye(4)
+        pose[:3, 3] = joint_positions[:3]
+        pose[:3, :3] = Rotation.from_rotvec(joint_positions[3:6]).as_matrix()
+        return pose
 
     def inverse_kinematics(self, *, end_effector_pose: np.ndarray,
-                           joint_reference: Optional[np.ndarray]) -> Optional[np.ndarray]:
-        return end_effector_pose[:3, 3]
+                           joint_reference=None) -> np.ndarray:
+        # trivial mock kinematics
+        position = end_effector_pose[:3, 3]
+        axis_angle = Rotation.from_matrix(end_effector_pose[:3, :3]).as_rotvec()
+        return np.concatenate([position, axis_angle])
 
     def are_joint_positions_safe(self, *, joint_positions: np.ndarray) -> bool:
         limits = self.get_joint_position_limits()
         for idx, position in enumerate(joint_positions):
-            if not limits[idx][0] < position < limits[idx][1]:
+            if not limits[idx][0] <= position <= limits[idx][1]:
                 return False
         return True
 
     def send_joint_positions(self, *, joint_positions: np.ndarray, step_count: int) -> None:
-        self.__joint_positions = np.copy(joint_positions)
+        self.__pose = self.forward_kinematics(joint_positions=joint_positions)
 
-    def command_move(self, *, joint_positions: np.array) -> None:
-        self.__joint_positions = np.copy(joint_positions)
+    def command_move(self, *, joint_positions: np.ndarray) -> None:
+        self.__pose = self.forward_kinematics(joint_positions=joint_positions)
 
     def command_stop(self) -> None:
         pass
+
+    def get_slowdown_steps_in_seconds(self) -> float:
+        return 0.05