Set robot activity state (thread-safe). Args: state: RobotActivityState - new robot activity state

Get robot activity state (thread-safe). Returns: RobotActivityState - current robot activity state

Set teleoperation state (thread-safe). Args: active: bool - whether teleop is active controller_initial: np.ndarray |

Get current joint angles (thread-safe). Returns: Current joint angles or None if not available

Called when a control button is pressed.

Called when a control button is released.

Gracefully stop the robot and move to home position.

Move robot to home position based on current control mode.

Request shutdown of all threads (lock-free using Event).

End continuous play and set robot activity state to ENABLED and update policy status.

Check if robot is enabled and ready to accept commands. Returns: True if robot is enabled, False otherwise

Update ghost robot visibility. Args: flag: Whether to show the ghost robot

Cleanup resources and disconnect from robot.

Resume robot operation by re-enabling it. This method can be called after emergency_stop() or graceful_stop() to re-enable the robot

Set target joint angles (thread-safe). Args: angles: np.ndarray - target joint angles

Stop the visualizer server.

Get the current control mode. Returns: Current control mode (PiperController.ControlMode.END_EFFECTOR or PiperController.ControlM

Check if robot is at home position within tolerance. Args: tolerance_degrees: Tolerance in degrees Returns:

Update target gripper position. Args: gripper_open_value: Gripper open value normalized (0.0 to 1.0).

Start the control loop thread.

Update policy status display. Args: status: Status string to display

Stop policy execution and unlock inputs (thread-safe).

Get continuous play active state (thread-safe).

Get current end effector pose (thread-safe). Returns: Current end effector pose or None if not available

Get the current measured joint angles from the robot, if available. Returns: numpy array or None: [j1, j2, j3, j4, j5, j6] or Non

Get prediction horizon length (thread-safe).

Get current joint configuration (thread-safe). Returns: Current target joint angles or None if not available

Get teleoperation active state (thread-safe).

Check if shutdown is requested (lock-free using Event). Returns: True if shutdown is requested, False otherwise

Handle Run Policy button press to capture state and get policy prediction.

Update 1€ Filter parameters for controller transform (thread-safe). Args: min_cutoff: Minimum cutoff frequency (stabilizes when h

Set IK solve time (thread-safe). Args: time_ms: float - IK solve time in milliseconds

Set IK success (thread-safe). Args: success: bool - True if IK was successful, False otherwise

Set target transform for visualization (thread-safe). Args: transform: np.ndarray | None - 4x4 transformation matrix or None to c

Handle Execute Policy button press to start policy execution.

Update ghost robot visualization from joint configuration. Args: joint_config: Joint angles in radians

Update toggle robot enabled status button label based on robot state. Args: enabled: Whether robot is currently enabled

Set the robot status enabled state (internal method). Args: enabled: True to enable robot, False to disable

Get current controller data (thread-safe). Returns: Tuple of (controller_transform, grip_value, trigger_value)

Get current gripper open value (thread-safe). Returns: Current gripper open value or None if not available

Get locked prediction horizon (thread-safe).

Get locked prediction horizon length (thread-safe).

Set the robot to a specific joint configuration. Args: joint_config: Array of joint angles to set Raises: Va

Set the robot to a specific joint configuration without updating the task. Args: joint_config: Array of joint angles to set

Set continuous play active state (thread-safe).

Set Execute Policy button disabled state. Args: disabled: Whether button should be disabled

Set target posture from a robot configuration. Args: configuration: Robot configuration.

Update with new position and orientation data. Args: position: [x, y, z] position in meters euler: [roll, pitch, yaw]

Update robot status display. Args: status: Status string to display

Create joint control buttons in the control frame.

Disable the robot.

Enable the robot.

Convert 6D pose [x, y, z, rx, ry, rz] to 4x4 transformation matrix. Args: pose_6d: 6D pose [x, y, z in mm, rx, ry, rz in degrees]

Add homing controls.

Add toggle robot enabled status button. This creates a single button that toggles between "Enable Robot" and "Disable Robot" based on

Apply exponential smoothing. Args: a: Smoothing factor (0.0-1.0) x: Current value x_prev: Previous smooth

Get current joint configuration (in radians).

Get the current measured end effector pose from the robot, if available. Returns: 4x4 transformation matrix or None if not availa

Get the current measured gripper open value from the robot, if available. Returns: float or None: Current gripper open value norm

Get execution mode (thread-safe).

Get prediction horizon (thread-safe).

Get RGB image (thread-safe).

Handle Button B press to move robot to home position.

Log current state to Neuracore.

Reset ghost action index (thread-safe).

Select random state and run policy.

Set the control mode. Args: mode: Control mode (PiperController.ControlMode.END_EFFECTOR or PiperController.ControlMode.JOINT_SPA

Set execution mode (thread-safe).

Set execution ratio used when locking prediction horizon.

Set ghost robot playing (thread-safe).

Set callback for Go Home button. Args: callback: Callback function to call when button is clicked

Set Play Policy button disabled state. Args: disabled: Whether button should be disabled

Set prediction horizon (thread-safe).

Set Run and Execute Policy button disabled state. Args: disabled: Whether button should be disabled

Set Run Policy button disabled state. Args: disabled: Whether button should be disabled

Set target posture. Args: target_q: Target vector in the configuration space. If the model has a floating base, t

Set target joint angles. Args: joint_angles: Target joint angles [j1, j2, j3, j4, j5, j6] in degrees

Set callback for toggle robot enabled status button. Args: callback: Callback function to call when button is clicked

Calculate smoothing factor for exponential smoothing. Args: t_e: Time elapsed since last update (in seconds) cutoff:

Start policy execution by locking inputs and storing horizon (thread-safe).

Stop the control loop thread.

Handle Button A press to toggle robot enable/disable state.

Update controller status display. Args: position: Controller position (3D array) or None connected: Whether controlle

Update filter parameters without resetting state. Args: min_cutoff: Minimum cutoff frequency beta: Speed coefficient

Update play policy button label based on active state. Args: active: Whether continuous play is currently active

Update robot visualization from joint configuration. Args: joint_config: Joint angles in radians

Build the robot model from URDF.

Create end-effector control buttons in the control frame.

Create the GUI elements.

Get list of available frame names.

Initialize robot connection and enable it.

Convert 4x4 transformation matrix to 6D pose [x, y, z, rx, ry, rz]. Args: transform: 4x4 transformation matrix Returns:

Schedule the next status update.

Send end-effector pose command to the robot. Args: transform: 4x4 transformation matrix

Send gripper command to the robot. Args: gripper_open_value_degrees: Gripper open value in degrees

Send joint angles command to the robot. Args: joint_angles: Joint angles [j1, j2, j3, j4, j5, j6] in degrees

Set up Pink tasks and configuration. Args: initial_configuration: Initial joint configuration (if None, uses neutral)

Update angular speed from user input.

Update gripper speed from user input.

Update joint speed from user input.