Jog Mode

SUMMARY

Jog mode is Cartesian Jogging and drives the TCP continuously at a Cartesian twist expressed in the selected feature frame - equivalent to holding a direction button on the teach pendant.

start_jog begins the continuous motion; the robot keeps moving at speeds until stop_jog is called.

stop_jog decelerates and halts the jog.

SUPPORTED ROBOTS

Currently supported only on Universal Robots.

UNITS

cartesian_velocity is [vx, vy, vz, ωx, ωy, ωz] in m/s and deg/s.

The Skill

# Start jogging the TCP in the base frame
robot.start_jog(speeds=[0.0, 0.0, 0.05, 0.0, 0.0, 0.0], feature=0, acc=0.5)

# Stop the jog and decelerate to a halt
robot.stop_jog()

The Code

Safety first!

A real robot will faithfully do whatever you ask of it - so please take a moment to clear the workspace, keep an E-Stop within reach, and be ready to disconnect.

Operating real hardware is at your own risk.

Example: Start, Use, and Stop a Jog Session

Jog the TCP at 5 cm/s along -Z in the base frame for 5 seconds, then stop cleanly.

"""
Start and stop jog mode example for the Synapse SDK.

``start_jog`` drives the TCP continuously at a Cartesian twist
``[vx, vy, vz (m/s), ωx, ωy, ωz (deg/s)]`` expressed in the ``feature``
frame, until ``stop_jog`` is called — equivalent to holding a direction
button on the teach pendant. ``feature`` selects the frame:
``0`` = base, ``1`` = tool, ``2`` = custom (provide ``custom_frame``).
This is Cartesian jogging — there is no joint-jog API.

Currently supported only for Universal Robots (UR10e).

Usage:
    python start_and_stop_jog_mode.py --ip <ROBOT_IP>
"""

import argparse
import time
from loguru import logger

from telekinesis.synapse.robots.manipulators import universal_robots


def main(robot_ip: str):
    """Jog the TCP -Z at 5 cm/s in the base frame for 5 seconds, then stop."""

    # Create robot instance
    robot = universal_robots.UniversalRobotsUR10E()

    # Connect to the robot
    robot.connect(ip=robot_ip)

    # Cartesian twist [vx, vy, vz (m/s), ωx, ωy, ωz (deg/s)] in the base frame
    cartesian_velocity = [0.0, 0.0, 0.05, 0.0, 0.0, 0.0]
    logger.info(f"Starting jog - cartesian_velocity [m/s, deg/s]: {cartesian_velocity}")
    robot.start_jog(
        cartesian_velocity=cartesian_velocity,
        feature=0,
        cartesian_acceleration=0.5,
    )

    # Let the jog run, then stop
    time.sleep(5.0)
    robot.stop_jog()
    logger.success("Jog mode stopped.")

    # Disconnect
    robot.disconnect()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="UR robot start and stop jog mode example")
    parser.add_argument("--ip", type=str, required=True, help="IP address of the UR robot")
    args = parser.parse_args()

    main(args.ip)

The Explanation of the Code

start_jog sends a Cartesian twist to the controller. cartesian_velocity is a 6-element vector [vx, vy, vz, ωx, ωy, ωz] with linear velocity in m/s and angular velocity in deg/s, expressed in the frame chosen by feature. feature selects the reference frame: 0 = base, 1 = tool, 2 = custom (provide custom_frame). cartesian_acceleration sets the TCP acceleration. The robot continues moving at this twist until stop_jog is called.

stop_jog sends a stop command to the controller, decelerating and halting any ongoing jog. Always call stop_jog after start_jog to prevent unintended continuous motion. If no jog is active, stop_jog is a no-op on most controllers and is safe to call defensively.

How to Tune the Parameters

start_jog

Parameter	Type	Default	Description
cartesian_velocity	list[float]	-	Cartesian twist [vx, vy, vz, ωx, ωy, ωz]. Linear in m/s, angular in deg/s, expressed in the feature frame.
feature	int	0	Reference frame: 0 = base, 1 = tool, 2 = custom.
cartesian_acceleration	float	0.5	TCP acceleration.
custom_frame	list[float]	[]	Pose [x, y, z, rx, ry, rz] of the custom reference frame. Used only when feature=2.

stop_jog

This skill takes no input parameters.

Return Value

Method	Type	Description
start_jog	None	Returns after the jog command is sent.
stop_jog	None	Returns after the stop command is sent.

Where to Use the Skill

• Interactive Cartesian positioning workflows.
• Aligning the TCP to a fixture or sensor with continuous motion in a chosen frame.
• Teach-pendant-style operator-guided motion from code.

When Not to Use the Skill

• Repeatable, waypoint-based positioning - use Set Cartesian Pose or Set Joint Positions.
• High-frequency real-time control - use Servo Joint or Servo Cartesian for streamed servo commands.