Skip to content

Intro

Welcome to the AIRBOT SDK documentation! This documentation also provides a one-pager here.

To quickly run AIRBOT series with SDK:

  1. Install airbot-configure package on the host

    Not applicable to AIBROT Pro

    sudo apt-get install ./airbot-configure_5.0.9-1_all.deb

    airbot-configure would install basic udev rules for setting up SocketCAN interfaces and also provides basic tools to bind devices to specific interface names. With airbot-configure installed, AIRBOT Play, AIRBOT Play Lite and AIRBOT Replay would appear as canX in the output of ip link.

  2. Connect to the device via a USB cable and power on the device with the power cable.

    Not applicable to AIBROT Pro

    If the LED is flashing in yellow, AIRBOT has detected loss of zero point reference. Refer to this tutorial for detailed operations.

    Also refer to this manual for available LED light effects and their meanings.

    With airbot-configure installed, AIRBOT Play, AIRBOT Play Lite and AIRBOT Replay would appear as canX in the output of ip link.

  3. Launch the driver server.

    Not applicable to AIBROT Pro

    The driver server (as a docker container) is typically launched via 

    # Specify a different version with IMAGE_NAME variable
# export IMAGE_NAME=registry.cn-shanghai.aliyuncs.com/discover-robotics/airbot_runtime:<version>
airbot_fsm -i <INTERFACE> -P <PORT>
    The driver server provides all the basic feature for AIRBOT series, include motor servoing, motion planning, collision checks, health checks, sdk servicing.

    • <INTERFACE> is the interface name that could be examined by ip link. By default, connected devices would appear as canX, where X is the index number.
    • <PORT> is the listening port of the gRPC server. In case multiple devices are connected, each device should use a different port.

  4. Install airbot_py pip package

    pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple ./airbot_py-5.0.9-py3-none-any.whl

  5. Connect to the server via SDK and perform external control

    By using this SDK, a client is created to connect to the driver server, so that states are obtained and commands are sent.

    For example, running keyboard control example: 

    python3 -m airbot_examples.task_kbd_ctrl

    For detailed explanation of key mappings, please refer to the Keyboard Control page.

    Please note that, SDK only serves as a "shell" to connect to the server, and is not responsible for managing the lifetime of the driver. This means multiple SDK client instances can connect to the driver simultaneously, but none of them "owns" the driver. The disconnection of SDK clients does NOT necessarily means the driver should and would shut down.

CHANGELOG

Version 5.0.9

Release date: 2025.04.17

Control Services

New Features

  • Largely optimize the performance of control server, now the CPU usage is reduced to less than half of the original.
  • Largely optimize launch time of control server, now the launch time is about 8 seconds with x86_64 host and 15 seconds on X5 RDK.
  • New feature: maximum torque protection during arm operation
  • This feature is intended to prevent the robot from severely damaging surrounding environment and is NOT a guarantee of absolute safety. It is strongly discouraged to solely rely on this feature to conduct any human-related interactions.
  • This feature also prevents motor from entering overload or over-temperature state.
  • The maximum torque can be set by the Python SDK: 
    # For motor #1 - #3, the param name start with "od_motor_<INTERFACE>_<INDEX>"
robot.set_params({"od_motor_can1_2.over_effort_thres": 10.0})
# For motor #4 - #6, the param name start with "dm_motor_<INTERFACE>_<INDEX>"
robot.set_params({"dm_motor_can1_5.over_effort_thres": 5.0})
  • The default threshold for motor #1 - #3 is 5.0 and for motor #4 - #6 is 2.0.
  • New feature: offline replaying
  • Paths recorded in the record-replay app can not be downloaded to AIRBOT Play and be played without external control services.
    • Double press base board button in Idle mode (constant cyan light effect)
    • During downloading, the light effect is rainbow
    • When downloading completes, the light effect returns to cyan
  • To replay the path once (in offline mode), long press the base board button when USB cable is unplugged (constant white light effect)
    • During replaying, the light effect is rainbow
    • When replaying completes, the light effect returns to constant white
  • To replay the path indefinitely (in offline mode), double press the base board button when USB cable is unplugged (constant white light effect)
    • During replaying, the light effect is rainbow
    • To interrupt the replaying, press once on the base board button, AIRBOT Play will wait for the current path to finish and then returns to home position and then stops
  • New feature: waypoint control mode:
  • Two new control modes are added: PLANNING_WAYPOINTS_PATH and PLANNING_WAYPOINTS
    • PLANNING_WAYPOINTS_PATH: Perform linear interpolation between waypoints in cartesian space, then execute the path without stopping.
    • PLANNING_WAYPOINTS: Perform local planning between adjacent waypoints, join the planned paths then execute the path. Deceleration may occur near waypoints.
  • Two new Python SDK methods are added: move_with_cart_waypoints and move_with_joint_waypoints
    • move_with_cart_waypoints: move the robot arm along a series of cartesian waypoints.
    • move_with_joint_waypoints: move the robot arm along a series of joint space waypoints.
    • please refer to Python SDK reference for detailed usage.
  • Two SDK examples are added: move_with_cart_waypoints and move_with_joint_waypoints for demonstration of newly added SDK methods.
    • python3 -m airbot_examples.move_with_cart_waypoints
    • python3 -m airbot_examples.move_with_joint_waypoints

Bug Fixes

  • Replace RNE (Recursive Newton-Euler) with deterministic analytical inverse kinematics solution. This solves the wrist flipping issue in previous versions.
  • Add check during launch to ensure that for each robot only one control service is currently running
  • Add check during launch to ensure that the same CAN bus is not occupied by multiple processes
  • Fix the issue of false alarming zero point reference loss when power is unplugged but USB cable is not unplugged
  • Fix the jitter issue when performing offline replay
  • Fix the light effect:
  • The light effect changes from constant green to constant white when powered on but no USB cable is plugged in
  • Fix the issue of incorrect zero point reference reset of E2 when powered on.
  • The E2 zero point reference is now calibrate at the factory (using the new production tool) and is not affected by the power on state.
  • Fix the precision issue of the URDF model. Lower the possibility of false positive collision detection.

Python SDK

New Features

Bug Fixes

  • task_kbd_ctrl: Align the home position of the arm with the home position when cleaning up.

Version 5.0.8

Release date: 2025.04.10

Python SDK

New Features

  • Add airbot_py.arm.SpeedProfile class to set speed profile for arm. Now the speed of the arm can be altered by robot.set_speed_profile(SpeedProfile.DEFAULT). Currently supported speed profiles are:
    • SpeedProfile.SLOW
    • SpeedProfile.DEFAULT
    • SpeedProfile.FAST: May move too fast. Use at your own risk!
  • Add get_params and set_params method to read / write parameters for internal nodes. Useful paramters:
    • servo_node.moveit_servo.scale.linear: linear speed scale in servo control modes
    • servo_node.moveit_servo.scale.rotational: rotational speed scale in servo control modes
    • servo_node.moveit_servo.scale.joint: joint speed scale in servo control modes
    • sdk_server.max_velocity_scaling_factor: velocity scale in planning control modes
    • sdk_server.max_acceleration_scaling_factor: acceleration scale in planning control modes
  • Add get_product_info method to obtain internal product information (product type, serial number, etc.)
  • Add exception handler to print details of exceptions in a human-readable format.
  • Add logging config for examples
  • Add end effector control in keyboard control example (using [ and ] to control)
  • Add speed profile switch in keyboard control example (using ENTER to switch)
  • Add joint-space and cartesian-space switch in keyboard control example (using SPACE to switch)
  • Add joint-space control in keyboard control example (using 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -, = to control)
  • Add speed profile arguments in examples -S [fast, default, slow]
  • Add product infomation print in get examples (get_joint_pos and get_end_pose)
  • Add position syncing before following in the task_follow example

Bug Fixes

  • Fix None returned by get_joint_eff
  • Use enum class RobotMode to replace plain integer to represent robot mode. Output of robot.get_control_mode() is now RobotMode instead of integer.
  • Use enum class State to replace plain integer to represent robot state. Output of robot.get_state() is now State instead of integer.
  • Unify the interfaces of end effector, now list[float] is passed and returned for get_eef_pos, set_eef_pos and servo_eef_pos.
  • Add support for Python 3.8 (to support Ubuntu 20.04)
  • Fix the incorrect always-true return value of load_app and unload_app methods.
  • Fix the exception raised by servo_eef_pos and move_eff_pos

Control Service

Bug Fixes

  • Slow down the speed of the arm on exit when returning to the starting point
  • Add torque limit to end effector controller to prevent motor entering overload or over-temperature state.
  • Fix the bugs when trying to load record_replay_app
  • Disable internal singularity check in moveit2, to avoid stuck when in servo control modes.
  • Fix possible timeout when sending planning request in PLANNING_POS mode

Shipping

New Features

Based on the 5.0.8 version of airbot-configure,

  • airbot_fsm is available now to launch control server in a docker container: 
    airbot_fsm -i <INTERFACE> -P <PORT>

  • airbot_iap is available now to upgrade the firmware of the boards.

    Firmware upgrade must not run simultaneously with control server! 

    airbot_iap -f <FILEPATH> -d <INTERFACE> --mask <INDEX> -t <TARGET>

Bug Fixes

  • Use 199 as the default ROS Domain ID to avoid conflict with other ROS 2 nodes.

Buttons and LEDs

Zero Point Calibration

For AIRBOT Play, if the LED is flashing in yellow, AIRBOT has detected loss of zero point reference.

In this case, long press the base button for 3 seconds, then the motor would be in free-drive status with large frictions. Drag the arm to the zero point position, and then press the base button again to finish the calibration.

After calibration, the LED would be breathing in green (if USB cable is connected), or breathing in white (if USB cable is not connected).

Concepts

This is a collection of concepts that are used throughout the SDK.

Driver State

The driver service works in a state machine that has these states:

  • IDLE: The driver is idle and waiting for commands. In this state, external commands \ can be sent to the driver and executed.
  • APPLOADING: The driver is loading an application. An application is an \ out-of-the-box module providing specific functionalities based on the driver. \ An application can be loaded by the driver and executed. The driver can only load \ one application at a time. One example of an application is the record_replay_app, \ which provides functionalities for recording and replaying the robot's motion.
  • APPLOADED: An application is loaded and running. In this state, if a read-write \ application is loaded, the driver would be in read-only state and, \ external controlling commands would be rejected by the server. \ Feedback service is still available.
  • ERROR: The driver is in error state.

Control Mode

TBD

APP

TBD

Firmware Upgrade

This tutorial applies to AIRBOT Play, AIRBOT Play Lite and AIRBOT Replay.

This tutorial does not apply to AIRBOT Pro.

  1. Install airbot-configure package on the host.

    airbot-configure would install basic udev rules for setting up SocketCAN interfaces and also provides basic tools to bind devices to specific interface names.

  2. Connect to the device via a USB cable.

    With airbot-configure installed, AIRBOT Play, AIRBOT Play Lite and AIRBOT Replay would appear as canX in the output of ip link.

  3. Upgrade the firmware via airbot_fsm command.

    Firmware upgrade must not run simultaneously with control server! 

    # Specify a different version with IMAGE_NAME variable
# export IMAGE_NAME=registry.cn-shanghai.aliyuncs.com/discover-robotics/airbot_runtime:<version>
airbot_iap -f <FILEPATH> -d <INTERFACE> --mask <INDEX> -t <TARGET>

Python SDK

API Reference

airbot_py

AIRBOT Python SDK

Modules:

Name Description
arm

This is the Python SDK for AIRBOT arm product series (AIRBOT Play, AIRBOT Pro, AIRBOT Play Lite

airbot_py.arm

This is the Python SDK for AIRBOT arm product series (AIRBOT Play, AIRBOT Pro, AIRBOT Play Lite and AIRBOT Replay). SDK for AIRBOT series is a thin gRPC client to communicate with driver.

Classes:

Name Description
AIRBOTArm

The client instance for AIRBOT arm series.
RobotMode

Enum for the control mode of the arm.
SpeedProfile

Enum for speed profile of the robot.
State

Enum for the state of the driver service.

Attributes:

Name Type Description
AIRBOTPlay

Alias for AIBROTArm
AIRBOTPlayLite

Alias for AIBROTArm
AIRBOTPro

Alias for AIBROTArm

airbot_py.arm.AIRBOTPlay = AIRBOTArm module-attribute

Alias for AIBROTArm

airbot_py.arm.AIRBOTPlayLite = AIRBOTArm module-attribute

Alias for AIBROTArm

airbot_py.arm.AIRBOTPro = AIRBOTArm module-attribute

Alias for AIBROTArm

airbot_py.arm.AIRBOTArm(url='localhost', port=50051)

The client instance for AIRBOT arm series.

Initialize SDK instance with default values. Would NOT perform any actions including connecting to server.

Parameters:

Name Type Description Default
url str

The listening url for the driver server. Default: "localhost"

 'localhost'
port int

The listening port for the driver server. Default: 50051

 50051

Methods:

Name Description
connect

Connect to the server if currently not connected.
disconnect

Disconnect from to the server if currently not connected.
get_control_mode

Obtain current control mode of the driver service.
get_eef_eff

Read current end effector torque output (in Nm) from the SDK server.
get_eef_pos

Read current end effector width (in meters) from the SDK server.
get_end_pose

Read current end pose from the SDK server.
get_joint_eff

Read current joint efforts (in Nm) from the SDK server.
get_joint_pos

Read current joint positions (in radian) from the SDK server.
get_joint_vel

Read current joint velocities (in radian/s) from the SDK server.
get_params

Get parameters from the driver server.
get_state

Obtain current state of the driver service.
load_app

Load an app to the driver server.
move_eef_pos

Send one joint position command to the end effector.
move_eff_pos

Previously name with typo for sending the command to the end effector.
move_to_cart_pose

Send one set of cartesian pose command to the robot.
move_to_joint_pos

Send one set of joint position command to the robot.
move_with_cart_waypoints

Move the robot arm along a series of cartesian waypoints.
move_with_joint_waypoints

Move the robot arm along a series of joint space waypoints.
servo_cart_pose

Send continuous cartesian pose commands to the robot.
servo_cart_twist

Send continuous cartesian twist commands to the robot.
servo_eef_force

Send continuous end effector force commands to the robot.
servo_eef_pos

Send continuous end effector width commands to the robot.
servo_joint_pos

Send continuous joint position commands to the robot.
servo_joint_vel

Send continuous joint velocity commands to the robot.
set_params

Set parameters to the driver server.
set_speed_profile

Set the speed profile of the robot.
switch_mode

Switch the control mode of the robot.
unload_app

Unload the app from the driver server.
Source code in airbot_py/arm.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def __init__(self, url: str = "localhost", port: int = 50051):
    """
    Initialize SDK instance with default values.
    Would NOT perform any actions including connecting to server.

    Args:
        url (str): The listening url for the driver server. Default: "localhost"
        port (int): The listening port for the driver server. Default: 50051
    """
    self.endpoint = url + ":" + str(port)
    self.logger = logging.getLogger(__name__)
    self.client_id = str(uuid.uuid4())
    self.logger.info("Client ID: %s", self.client_id)
    self._control_stub = None
    self._feedback_stub = None
    self._utils_stub = None
    self._channel = None
    self._feedback_jointstates = None
    self._feedback_end_poses = None
    self._feedback_thread = None
    self._servo_eef_cmd_queue = deque(maxlen=10)
    self._servo_cmd_queue = deque(maxlen=10)
    self._servo_condition = threading.Semaphore(0)
    self._servo_stop_event = threading.Event()
    self._servo_thread = None
    self._end_joint_states = None
    self._feedbacking = False
airbot_py.arm.AIRBOTArm.connect()

Connect to the server if currently not connected.

Directly calling this method is deprecated in favor of using the with statement:

# Use:
with AIRBOTArm() as robot:
    ...

# instead of
robot = AIRBOTArm()
robot.connect()
...
robot.disconnect()

This method is idempotent. Calling this method if SDK has already conencted to the server would cause no harm.

Returns:

Name Type Description
result bool

True if connected successfully
Source code in airbot_py/arm.py 
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
def connect(self) -> bool:
    """
    Connect to the server if currently not connected.

    Directly calling this method is deprecated in favor of using the `with` statement:

    ```python
    # Use:
    with AIRBOTArm() as robot:
        ...

    # instead of
    robot = AIRBOTArm()
    robot.connect()
    ...
    robot.disconnect()
    ```

    This method is idempotent. Calling this method if SDK has already
    conencted to the server would cause no harm.

    Returns:
        result (bool): True if connected successfully
    """
    if self._control_stub is None:
        self._channel = grpc.insecure_channel(self.endpoint)
        self._control_stub = arm_pb2_grpc.ControlServiceStub(self._channel)
        self._feedback_stub = arm_pb2_grpc.FeedbackServiceStub(self._channel)
        self._utils_stub = utils_pb2_grpc.UtilsServiceStub(self._channel)

        self._feedbacking = True
        self._feedback_thread = threading.Thread(target=self._status)
        self._feedback_thread.start()
        start_time = time.time()
        while self._feedback_jointstates is None:
            time.sleep(0.01)
            if time.time() - start_time > 1:
                logging.error("Failed to connect to the server.")
                self._feedbacking = False
                self._feedback_thread.join()
                self._feedback_thread = None
                self._control_stub = None
                self._feedback_stub = None
                self._utils_stub = None
                if self._channel is not None:
                    self._channel.close()
                self._channel = None
                return False

        return True
    else:
        logging.warning("Already connected to the server.")
        return True
airbot_py.arm.AIRBOTArm.disconnect()

Disconnect from to the server if currently not connected.

Directly calling this method is deprecated in favor of using the with statement:

# Use:
with AIRBOTArm() as robot:
    ...

# instead of
robot = AIRBOTArm()
robot.connect()
...
robot.disconnect()

This method is idempotent. Calling this method if SDK has already disconnected from the server would cause no harm.

Returns:

Name Type Description
result bool

True if connected successfully
Source code in airbot_py/arm.py 
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
def disconnect(self) -> bool:
    """
    Disconnect from to the server if currently not connected.

    Directly calling this method is deprecated in favor of using the `with` statement:

    ```python
    # Use:
    with AIRBOTArm() as robot:
        ...

    # instead of
    robot = AIRBOTArm()
    robot.connect()
    ...
    robot.disconnect()
    ```

    This method is idempotent. Calling this method if SDK has already
    disconnected from the server would cause no harm.

    Returns:
        result(bool): True if connected successfully
    """
    if self._feedbacking:
        self._feedbacking = False
        if self._feedback_thread is not None:
            self._feedback_thread.join()
            self._feedback_thread = None

    self._servo_cmd_queue.clear()
    self._servo_stop_event.set()
    if self._servo_thread is not None:
        self._servo_thread.join()
        self._servo_thread = None
    self._servo_stop_event.clear()
    self._servo_condition = threading.Semaphore(0)

    if self._control_stub is not None:
        self._control_stub = None
        self._feedback_stub = None
        self._utils_stub = None
        self._channel.close()
        self._channel = None
        return True
    else:
        logging.warning("Already disconnected from the server.")
        return True
airbot_py.arm.AIRBOTArm.get_control_mode()

Obtain current control mode of the driver service.

Returns:

Name Type Description
mode RobotMode

The current control mode of the driver service.
Source code in airbot_py/arm.py 
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
@grpc_safe()
def get_control_mode(self) -> Optional[RobotMode]:
    """
    Obtain current control mode of the driver service.

    Returns:
        mode (RobotMode): The current control mode of the driver service.
    """
    stamp = time.time_ns()
    request = arm_pb2.GetModeRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id
    request.component_names[:] = ["arm"]

    response = self._feedback_stub.GetMode(request)
    return RobotMode(response.modes[0]) if response.modes else None
airbot_py.arm.AIRBOTArm.get_eef_eff()

Read current end effector torque output (in Nm) from the SDK server. Currently only parallel two-finger end effector is supported.

If no end effector is installed, an empty list is returned.

If the SDK has not received joint states from the server, None is returned.

Returns:

Name Type Description
eef_eff list[float]

the current end effector torque output of the arm. None if SDK has not received joint states or no end effector is installed.
Source code in airbot_py/arm.py 
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
@grpc_safe()
def get_eef_eff(self) -> Optional[List[float]]:
    """
    Read current end effector torque output (in Nm) from the SDK server.
    Currently only parallel two-finger end effector is supported.

    If no end effector is installed, an empty list is returned.

    If the SDK has not received joint states from the server, None is returned.

    Returns:
        eef_eff (list[float]): the current end effector torque output of the arm. \
        None if SDK has not received joint states or no end \
        effector is installed.
    """
    if self._feedback_jointstates is None:
        logging.error("No joint states received yet.")
        return None
    else:
        return [
            i[1]
            for i in sorted(
                [
                    (name, effort)
                    for name, effort in zip(
                        self._feedback_jointstates.name,
                        self._feedback_jointstates.effort,
                    )
                ],
                key=lambda x: x[0],
            )
            if i[0] == "gripper_mapping_controller"
        ]
airbot_py.arm.AIRBOTArm.get_eef_pos()

Read current end effector width (in meters) from the SDK server. Currently only parallel two-finger end effector is supported.

If no end effector is installed, an empty list is returned.

If the SDK has not received joint states from the server, None is returned.

Returns:

Name Type Description
eef_pos list[float] | None

the current end effector width of the arm. None if SDK has not received joint states or no end effector is installed.
Source code in airbot_py/arm.py 
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
@grpc_safe()
def get_eef_pos(self) -> Optional[List[float]]:
    """
    Read current end effector width (in meters) from the SDK server.
    Currently only parallel two-finger end effector is supported.

    If no end effector is installed, an empty list is returned.

    If the SDK has not received joint states from the server, None is returned.

    Returns:
        eef_pos (list[float] | None): the current end effector width of the arm. \
        None if SDK has not received joint states or no end \
        effector is installed.
    """
    if self._feedback_jointstates is None:
        logging.error("No joint states received yet.")
        return None
    else:
        return [
            i[1]
            for i in sorted(
                [
                    (name, position)
                    for name, position in zip(
                        self._feedback_jointstates.name,
                        self._feedback_jointstates.position,
                    )
                ],
                key=lambda x: x[0],
            )
            if i[0] == "gripper_mapping_controller"
        ]
airbot_py.arm.AIRBOTArm.get_end_pose()

Read current end pose from the SDK server.

The zero point of the reference frame for the end pose is the intersection point of the rotating axis of first joint and installing plane. The axes of reference frame for the end are x axis pointing forward, y axis pointing leftward and z axis pointing upward.

If no end effector is installed, the pose of the end flange is returned. If any end effector is installed, the pose of the effecting point is returned. For example, the effecting point of AIRBOT G2 is the grasping point in the front.

TODO: Replace with actual doc url For detailed explanation of the reference frame and the end link used for get_end_pose, please refer to https://www.bing.com

Returns:

Name Type Description
end_pose list[list[float]]

A list of two float-list. The first list is the cartesian translation of the pose in meters, and the second list is the orientation quaternion (x, y, z, w) of the pose.
Source code in airbot_py/arm.py 
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
@grpc_safe()
def get_end_pose(self) -> Optional[List[List[float]]]:
    """
    Read current end pose from the SDK server.

    The zero point of the reference frame for the end pose is the intersection point
    of the rotating axis of first joint and installing plane.
    The axes of reference frame for the end are x axis pointing forward, y axis
    pointing leftward and z axis pointing upward.

    If no end effector is installed, the pose of the end flange is returned.
    If any end effector is installed, the pose of the effecting point
    is returned. For example, the effecting point of AIRBOT G2 is the grasping
    point in the front.

    TODO: Replace with actual doc url
    For detailed explanation of the reference frame and the end link used
    for get_end_pose, please refer to [https://www.bing.com](https://www.bing.com)

    Returns:
        end_pose (list[list[float]]): A list of two float-list. The first list is \
        the cartesian translation of the pose in meters, and the second list \
        is the orientation quaternion (x, y, z, w) of the pose.

    """
    if self._feedback_end_poses is None:
        logging.error("No end poses received yet.")
        return None
    else:
        return [
            [
                self._feedback_end_poses.translation.x,
                self._feedback_end_poses.translation.y,
                self._feedback_end_poses.translation.z,
            ],
            [
                self._feedback_end_poses.orientation.x,
                self._feedback_end_poses.orientation.y,
                self._feedback_end_poses.orientation.z,
                self._feedback_end_poses.orientation.w,
            ],
        ]
airbot_py.arm.AIRBOTArm.get_joint_eff()

Read current joint efforts (in Nm) from the SDK server.

The returned list only contains the joint efforts of the arm itself. The position of the end effector (if any) is not included.

If SDK has not received joint states from the server, None is returned.

Returns:

Name Type Description
joint_eff float | None

the current efforts of the arm joints.
Source code in airbot_py/arm.py 
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
@grpc_safe()
def get_joint_eff(self) -> Optional[List[float]]:
    """
    Read current joint efforts (in Nm) from the SDK server.

    The returned list only contains the joint efforts of the arm itself.
    The position of the end effector (if any) is not included.

    If SDK has not received joint states from the server, None is returned.

    Returns:
        joint_eff (float | None): the current efforts of the arm joints.
    """
    if self._feedback_jointstates is None:
        logging.error("No joint states received yet.")
        return None
    else:
        return [
            i[1]
            for i in sorted(
                [
                    (name, effort)
                    for name, effort in zip(
                        self._feedback_jointstates.name,
                        self._feedback_jointstates.effort,
                    )
                ],
                key=lambda x: x[0],
            )
            if i[0].startswith("joint")
        ]
airbot_py.arm.AIRBOTArm.get_joint_pos()

Read current joint positions (in radian) from the SDK server.

The returned list only contains the joint positions of the arm itself. The position of the end effector (if any) is not included.

If SDK has not received joint states from the server, None is returned

Returns:

Name Type Description
joint_pos list[float] | None

the current positions of the arm joints.
Source code in airbot_py/arm.py 
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
@grpc_safe()
def get_joint_pos(self) -> Optional[List[float]]:
    """
    Read current joint positions (in radian) from the SDK server.

    The returned list only contains the joint positions of the arm itself.
    The position of the end effector (if any) is not included.

    If SDK has not received joint states from the server, None is returned

    Returns:
        joint_pos (list[float] | None): the current positions of the arm joints.
    """
    if self._feedback_jointstates is None:
        logging.error("No joint states received yet.")
        return None
    else:
        return [
            i[1]
            for i in sorted(
                [
                    (name, position)
                    for name, position in zip(
                        self._feedback_jointstates.name,
                        self._feedback_jointstates.position,
                    )
                ],
                key=lambda x: x[0],
            )
            if i[0].startswith("joint")
        ]
airbot_py.arm.AIRBOTArm.get_joint_vel()

Read current joint velocities (in radian/s) from the SDK server.

The returned list only contains the joint velocities of the arm itself. The position of the end effector (if any) is not included.

If SDK has not received joint states from the server, None is returned

Returns:

Name Type Description
joint_vel list[float] | None

the current velocities of the arm joints.
Source code in airbot_py/arm.py 
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
@grpc_safe()
def get_joint_vel(self) -> Optional[List[float]]:
    """
    Read current joint velocities (in radian/s) from the SDK server.

    The returned list only contains the joint velocities of the arm itself.
    The position of the end effector (if any) is not included.

    If SDK has not received joint states from the server, None is returned

    Returns:
        joint_vel (list[float] | None): the current velocities of the arm joints.
    """
    if self._feedback_jointstates is None:
        logging.error("No joint states received yet.")
        return None
    else:
        return [
            i[1]
            for i in sorted(
                [
                    (name, velocity)
                    for name, velocity in zip(
                        self._feedback_jointstates.name,
                        self._feedback_jointstates.velocity,
                    )
                ],
                key=lambda x: x[0],
            )
            if i[0].startswith("joint")
        ]
airbot_py.arm.AIRBOTArm.get_params(names)

Get parameters from the driver server.

Parameters:

Name Type Description Default
names list[str]

The names of the parameters to get.

 required

Returns: params (dict): A dictionary of the parameters.

Source code in airbot_py/arm.py 
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
@grpc_safe()
def get_params(self, names: List[str]) -> Dict[str, Any]:
    """
    Get parameters from the driver server.

    Args:
        names (list[str]): The names of the parameters to get.
    Returns:
        params (dict): A dictionary of the parameters.
    """
    if len(names) == 0:
        logging.error("No parameter names provided.")
        return {}
    stamp = time.time_ns()
    request = arm_pb2.GetParamsRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id
    request.keys[:] = names

    response = self._feedback_stub.GetParams(request)
    return {
        k: getattr(v, v.WhichOneof("union"))
        for k, v in zip(response.keys, response.values)
    }
airbot_py.arm.AIRBOTArm.get_state()

Obtain current state of the driver service.

Returns:

Name Type Description
state State

The current state of the driver service.
Source code in airbot_py/arm.py 
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
@grpc_safe()
def get_state(self) -> State:
    """
    Obtain current state of the driver service.

    Returns:
        state (State): The current state of the driver service.
    """
    stamp = time.time_ns()
    request = utils_pb2.GetStateRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id

    response = self._utils_stub.GetState(request)
    return State(response.state)
airbot_py.arm.AIRBOTArm.load_app(name, params=None)

Load an app to the driver server.

When an read-write app is loaded, the SDK would enter read-only state, in which get methods are available but set methods are blocked. See available states

Currently available apps: * record_replay_app/record_replay_app::RecordReplayApp

Parameters:

Name Type Description Default
name str

The name of the app to load.

 required
params dict

The parameters for the app. Default: {}

 None

Returns:

Name Type Description
result bool

True if the app was loaded successfully, False otherwise.
Source code in airbot_py/arm.py 
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
@grpc_safe()
def load_app(self, name: str, params: Optional[dict] = None) -> bool:
    """
    Load an app to the driver server.

    When an read-write app is loaded, the SDK would enter read-only state,
    in which get methods are available but set methods are blocked. See
    [available states](./#airbot_py.arm--internal-states-of-the-driver)

    Currently available apps:
    * `record_replay_app/record_replay_app::RecordReplayApp`

    Args:
        name (str): The name of the app to load.
        params (dict): The parameters for the app. Default: {}

    Returns:
        result (bool): True if the app was loaded successfully, False otherwise.
    """
    stamp = time.time_ns()
    request = utils_pb2.LoadAppRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id
    request.app_name = name
    if params is not None:
        for key, value in params.items():
            request.params_key.append(key)
            request.params_value.append(str(value))

    response = self._utils_stub.LoadApp(request)
    return response.ok
airbot_py.arm.AIRBOTArm.move_eef_pos(joint_pos, blocking=True)

Send one joint position command to the end effector.

Effective for parallel two-finger end effector only.

Before calling this method, the robot should be in PLANNING_POS mode, otherwise the command would be ignored.

Parameters:

Name Type Description Default
joint_pos list[float]

The end effector width commands in meters.

 required

Returns:

Name Type Description
result bool

True if the command was sent successfully, False otherwise.
Source code in airbot_py/arm.py 
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
@grpc_safe()
def move_eef_pos(
    self,
    joint_pos: Union[List[float], float],
    blocking: bool = True,
) -> bool:
    """
    Send one joint position command to the end effector.

    Effective for parallel two-finger end effector only.

    Before calling this method, the robot should be in `PLANNING_POS` mode,
    otherwise the command would be ignored.

    Args:
        joint_pos (list[float]): The end effector width commands in meters.

    Returns:
        result (bool): True if the command was sent successfully, False otherwise.
    """
    # For backward compatibility
    if not isinstance(joint_pos, list):
        joint_pos = [joint_pos]

    def _generate_joint_pos(
        joint_pos: List[float],
    ) -> Iterator[arm_pb2.SetStateRequest]:
        request = arm_pb2.SetStateRequest()
        joint_states = types_pb2.JointStates()
        now = time.time_ns()
        request.stamp.sec = int(now / 1e9)
        request.stamp.nanosec = int(now % 1e9)
        request.request_id = self.client_id
        request.component_names[:] = ["eef"]
        joint_states.name[:] = ["eef"]
        joint_states.position[:] = joint_pos
        request.commands.add(joint_states=joint_states)
        yield request

    result_iter = self._control_stub.SetState(_generate_joint_pos(joint_pos))

    first_result = next(result_iter, None)
    if first_result is not None and first_result.status != arm_pb2.Status.ACCEPTED:
        self.logger.error("Failed to move to joint position")
        return False

    return True
airbot_py.arm.AIRBOTArm.move_eff_pos(joint_pos, blocking=True)

Previously name with typo for sending the command to the end effector. Renamed to move_eef_pos, but kept for backward compatibility.

Source code in airbot_py/arm.py 
875
876
877
878
879
880
881
882
883
884
885
@grpc_safe()
def move_eff_pos(
    self,
    joint_pos: Union[List[float], float],
    blocking: bool = True,
) -> bool:
    """
    Previously name with typo for sending the command to the end effector.
    Renamed to `move_eef_pos`, but kept for backward compatibility.
    """
    return self.move_eef_pos(joint_pos, blocking)
airbot_py.arm.AIRBOTArm.move_to_cart_pose(cart_pose, blocking=True)

Send one set of cartesian pose command to the robot.

The cartesian pose command is sent to the driver server, and the robot would plan a path to reach the target cartesian pose then execute it.

The zero point of the reference frame for the end pose is the intersection point of the rotating axis of first joint and installing plane. The axes of reference frame for the end are x axis pointing forward, y axis pointing leftward and z axis pointing upward.

Parameters:

Name Type Description Default
cart_pose list[list[float]]

The cartesian pose commands. The first list is the cartesian translation of the pose in meters, and the second list is the orientation quaternion (x, y, z, w) of the pose.

 required
blocking bool

Whether to block until the command is finished. Default: True

 True

Returns:

Name Type Description
result bool

True if the command was sent successfully, False otherwise.
Source code in airbot_py/arm.py 
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
@grpc_safe()
def move_to_cart_pose(
    self,
    cart_pose: List[List[float]],
    blocking: bool = True,
) -> bool:
    """
    Send one set of cartesian pose command to the robot.

    The cartesian pose command is sent to the driver server, and the robot
    would plan a path to reach the target cartesian pose then execute it.

    The zero point of the reference frame for the end pose is the intersection point
    of the rotating axis of first joint and installing plane.
    The axes of reference frame for the end are x axis pointing forward, y axis
    pointing leftward and z axis pointing upward.

    Args:
        cart_pose (list[list[float]]): The cartesian pose commands. \
            The first list is the cartesian translation of the pose in meters, \
            and the second list is the orientation quaternion (x, y, z, w) of the pose.
        blocking (bool): Whether to block until the command is finished. \
            Default: True

    Returns:
        result (bool): True if the command was sent successfully, False otherwise.
    """

    def _generate_cart_pose(
        cart_pose: List[List[float]],
    ) -> Iterator[arm_pb2.SetStateRequest]:
        transform = types_pb2.Transform()
        request = arm_pb2.SetStateRequest()
        now = time.time_ns()
        request.stamp.sec = int(now / 1e9)
        request.stamp.nanosec = int(now % 1e9)
        request.request_id = self.client_id
        request.component_names[:] = ["arm"]
        transform.translation.x = cart_pose[0][0]
        transform.translation.y = cart_pose[0][1]
        transform.translation.z = cart_pose[0][2]
        transform.orientation.x = cart_pose[1][0]
        transform.orientation.y = cart_pose[1][1]
        transform.orientation.z = cart_pose[1][2]
        transform.orientation.w = cart_pose[1][3]
        request.commands.add(transform=transform)
        yield request

    result_iter = self._control_stub.SetState(_generate_cart_pose(cart_pose))

    first_result = next(result_iter)
    if first_result.status != arm_pb2.Status.ACCEPTED:
        self.logger.error("Failed to move to joint position")
        return False

    if blocking:
        for result in result_iter:
            if result.status == arm_pb2.Status.FINISHED:
                self.logger.info("Moving to joint position...")
                return True
        return False
    else:
        return True
airbot_py.arm.AIRBOTArm.move_to_joint_pos(joint_pos, blocking=True)

Send one set of joint position command to the robot.

The joint position command is sent to the driver server, and the robot would plan a path to reach the target joint position then execute it.

Before calling this method, the robot should be in PLANNING_POS mode, otherwise the command would be ignored.

Parameters:

Name Type Description Default
joint_pos list[float]

The joint position commands in radian.

 required
blocking bool

Whether to block until the command is finished. Default: True

 True

Returns:

Name Type Description
result bool

True if the command was sent successfully, False otherwise.
Source code in airbot_py/arm.py 
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
@grpc_safe()
def move_to_joint_pos(
    self,
    joint_pos: List[float],
    blocking: bool = True,
) -> bool:
    """
    Send one set of joint position command to the robot.

    The joint position command is sent to the driver server, and the robot
    would plan a path to reach the target joint position then execute it.

    Before calling this method, the robot should be in `PLANNING_POS` mode,
    otherwise the command would be ignored.

    Args:
        joint_pos (list[float]): The joint position commands in radian.
        blocking (bool): Whether to block until the command is finished.
            Default: True

    Returns:
        result (bool): True if the command was sent successfully, False otherwise.
    """

    def _generate_joint_pos(
        joint_pos: List[float],
    ) -> Iterator[arm_pb2.SetStateRequest]:
        request = arm_pb2.SetStateRequest()
        joint_states = types_pb2.JointStates()
        now = time.time_ns()
        request.stamp.sec = int(now / 1e9)
        request.stamp.nanosec = int(now % 1e9)
        request.request_id = self.client_id
        request.component_names[:] = ["arm"]
        joint_states.name[:] = [
            "joint1",
            "joint2",
            "joint3",
            "joint4",
            "joint5",
            "joint6",
        ]
        joint_states.position[:] = joint_pos
        request.commands.add(joint_states=joint_states)
        yield request

    result_iter = self._control_stub.SetState(_generate_joint_pos(joint_pos))

    first_result = next(result_iter)
    if first_result.status != arm_pb2.Status.ACCEPTED:
        self.logger.error("Failed to move to joint position")
        return False

    if blocking:
        for result in result_iter:
            if result.status == arm_pb2.Status.FINISHED:
                self.logger.info("Moving to joint position...")
                return True
        return False
    else:
        return True
airbot_py.arm.AIRBOTArm.move_with_cart_waypoints(waypoints, blocking=True)

Move the robot arm along a series of cartesian waypoints.

The robot will interpolate through the given list of poses.

Parameters:

Name Type Description Default
waypoints list[list[list[float]]]

A list of poses, where each pose is a 2-element list: [translation, orientation] - translation: list of 3 floats (x, y, z) in meters - orientation: list of 4 floats (x, y, z, w) as quaternion

 required
blocking bool

Whether to wait until execution is finished.

 True

Returns:

Name Type Description
bool bool

True if the command was accepted and (optionally) completed.
Source code in airbot_py/arm.py 
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
@grpc_safe()
def move_with_cart_waypoints(
    self,
    waypoints: list[list[list[float]]],
    blocking: bool = True,
) -> bool:
    """
    Move the robot arm along a series of cartesian waypoints.

    The robot will interpolate through the given list of poses.

    Args:
        waypoints (list[list[list[float]]]): A list of poses, where each pose is a
            2-element list: [translation, orientation]
            - translation: list of 3 floats (x, y, z) in meters
            - orientation: list of 4 floats (x, y, z, w) as quaternion
        blocking (bool): Whether to wait until execution is finished.

    Returns:
        bool: True if the command was accepted and (optionally) completed.
    """

    def _generate_waypoints(
        cart_pose: list[list[list[float]]],
    ) -> Iterator[arm_pb2.SetStateRequest]:
        waypoints_obj = types_pb2.WayPoints()
        request = arm_pb2.SetStateRequest()
        now = time.time_ns()
        request.stamp.sec = int(now / 1e9)
        request.stamp.nanosec = int(now % 1e9)
        request.request_id = self.client_id
        request.component_names[:] = ["arm"]
        for e in cart_pose:
            transform = types_pb2.Transform()
            transform.translation.x = e[0][0]
            transform.translation.y = e[0][1]
            transform.translation.z = e[0][2]
            transform.orientation.x = e[1][0]
            transform.orientation.y = e[1][1]
            transform.orientation.z = e[1][2]
            transform.orientation.w = e[1][3]
            waypoints_obj.transform_array.extend([transform])

        command = types_pb2.Command()
        command.waypoints.CopyFrom(waypoints_obj)
        request.commands.append(command)
        yield request

    result_iter = self._control_stub.SetState(_generate_waypoints(waypoints))
    first_result = next(result_iter)
    if first_result.status != arm_pb2.Status.ACCEPTED:
        self.logger.error("Failed to move to joint position")
        return False
    if blocking:
        print("Waiting for arm to finish moving...")
        for result in result_iter:
            if result.status == arm_pb2.Status.FINISHED:
                self.logger.info("Arm movement finished")
                return True
        return False
    else:
        return True
airbot_py.arm.AIRBOTArm.move_with_joint_waypoints(waypoints, blocking=True)

Move the robot arm along a series of joint space waypoints.

Parameters:

Name Type Description Default
waypoints list[list[list[float]]]

A list of joint angle sets. Each element is a list of joint positions (floats) for the 6 joints [joint1, ..., joint6].

 required
blocking bool

Whether to wait until execution is finished.

 True

Returns:

Name Type Description
bool bool

True if the command was accepted and (optionally) completed.
Source code in airbot_py/arm.py 
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
@grpc_safe()
def move_with_joint_waypoints(
    self,
    waypoints: list[list[list[float]]],
    blocking: bool = True,
) -> bool:
    """
    Move the robot arm along a series of joint space waypoints.

    Args:
        waypoints (list[list[list[float]]]): A list of joint angle sets. Each element is a list of
            joint positions (floats) for the 6 joints [joint1, ..., joint6].
        blocking (bool): Whether to wait until execution is finished.

    Returns:
        bool: True if the command was accepted and (optionally) completed.
    """

    def _generate_waypoints(
        joint_pose: list[list[list[float]]],
    ) -> Iterator[arm_pb2.SetStateRequest]:
        waypoints_obj = types_pb2.WayPoints()
        request = arm_pb2.SetStateRequest()
        now = time.time_ns()
        request.stamp.sec = int(now / 1e9)
        request.stamp.nanosec = int(now % 1e9)
        request.request_id = self.client_id
        request.component_names[:] = ["arm"]

        for e in joint_pose:
            joint_states = types_pb2.JointStates()
            joint_states.name[:] = [
                "joint1",
                "joint2",
                "joint3",
                "joint4",
                "joint5",
                "joint6",
            ]
            joint_states.position[:] = e
            waypoints_obj.joint_states_array.extend([joint_states])

        command = types_pb2.Command()
        command.waypoints.CopyFrom(waypoints_obj)
        request.commands.append(command)
        yield request

    result_iter = self._control_stub.SetState(_generate_waypoints(waypoints))
    first_result = next(result_iter)
    if first_result.status != arm_pb2.Status.ACCEPTED:
        self.logger.error("Failed to move to joint position")
        return False
    if blocking:
        print("Waiting for arm to finish moving...")
        for result in result_iter:
            if result.status == arm_pb2.Status.FINISHED:
                self.logger.info("Arm movement finished")
                return True
        return False
    else:
        return True
airbot_py.arm.AIRBOTArm.servo_cart_pose(cart_pose)

Send continuous cartesian pose commands to the robot.

The robot end point (end flange if no end effector installed, otherwise the effecting point of the end effector) would follow the cartesian pose commands, each of which representing the expected cartesian pose of the end flange or the effecting point of the end effector.

Before calling this method, the robot should be in SERVO_CART_POSE mode, otherwise the command would be ignored.

Parameters:

Name Type Description Default
cart_pose list[list[float]]

The cartesian pose commands. The first list is the cartesian translation of the pose in meters, and the second list is the orientation (x, y, z, w) quaternion of the pose.

 required
Source code in airbot_py/arm.py 
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
@grpc_safe()
def servo_cart_pose(self, cart_pose: List[List[float]]) -> None:
    """
    Send continuous cartesian pose commands to the robot.

    The robot end point (end flange if no end effector installed, otherwise
    the effecting point of the end effector) would follow the cartesian pose
    commands, each of which representing the expected cartesian pose of the end
    flange or the effecting point of the end effector.

    Before calling this method, the robot should be in `SERVO_CART_POSE`
    mode, otherwise the command would be ignored.

    Args:
        cart_pose (list[list[float]]): The cartesian pose commands. \
            The first list is the cartesian translation of the pose in meters, \
            and the second list is the orientation (x, y, z, w) quaternion of the pose.
    """
    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.Transform()
    servo_cmd.translation.x = cart_pose[0][0]
    servo_cmd.translation.y = cart_pose[0][1]
    servo_cmd.translation.z = cart_pose[0][2]
    servo_cmd.orientation.x = cart_pose[1][0]
    servo_cmd.orientation.y = cart_pose[1][1]
    servo_cmd.orientation.z = cart_pose[1][2]
    servo_cmd.orientation.w = cart_pose[1][3]
    self._servo_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.servo_cart_twist(cart_twist)

Send continuous cartesian twist commands to the robot.

The robot end point (end flange if no end effector installed, otherwise the effecting point of the end effector) would follow the cartesian twist commands, each of which representing the expected translational and rotational velocity of the end flange or the effecting point of the end effector.

Before calling this method, the robot should be in SERVO_CART_TWIST mode, otherwise the command would be ignored.

Parameters:

Name Type Description Default
cart_twist list[list[float]]

The cartesian twist commands. The first list is the translational velocity of the end flange or the effecting point of the end effector, and the second list is the rotational velocity of the end flange or the effecting point of the end effector.

 required
Source code in airbot_py/arm.py 
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
@grpc_safe()
def servo_cart_twist(self, cart_twist: List[List[float]]) -> None:
    """
    Send continuous cartesian twist commands to the robot.

    The robot end point (end flange if no end effector installed, otherwise
    the effecting point of the end effector) would follow the cartesian twist
    commands, each of which representing the expected translational and
    rotational velocity of the end flange or the effecting point of the end
    effector.

    Before calling this method, the robot should be in `SERVO_CART_TWIST`
    mode, otherwise the command would be ignored.

    Args:
        cart_twist (list[list[float]]): The cartesian twist commands. \
            The first list is the translational velocity of the end flange \
            or the effecting point of the end effector, and the second list \
            is the rotational velocity of the end flange or the effecting point \
            of the end effector.
    """
    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.Twist()
    servo_cmd.linear.x = cart_twist[0][0]
    servo_cmd.linear.y = cart_twist[0][1]
    servo_cmd.linear.z = cart_twist[0][2]
    servo_cmd.angular.x = cart_twist[1][0]
    servo_cmd.angular.y = cart_twist[1][1]
    servo_cmd.angular.z = cart_twist[1][2]
    self._servo_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.servo_eef_force(force)

Send continuous end effector force commands to the robot.

Effective for parallel two-finger end effector only.

Before calling this method, the robot should be in one of the "servo" states (SERVO_CART_TWIST, SERVO_CART_POSE, SERVO_JOINT_POS, SERVO_JOINT_VEL), otherwise the command would be ignored.

Parameters:

Name Type Description Default
force list[float]

The end effector force commands in Newton.

 required
Source code in airbot_py/arm.py 
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
@grpc_safe()
def servo_eef_force(self, force: List[float]) -> None:
    """
    Send continuous end effector force commands to the robot.

    Effective for parallel two-finger end effector only.

    Before calling this method, the robot should be in one of the "servo"
    states (`SERVO_CART_TWIST`, `SERVO_CART_POSE`, `SERVO_JOINT_POS`,
    `SERVO_JOINT_VEL`), otherwise the command would be ignored.

    Args:
        force (list[float]): The end effector force commands in Newton.
    """
    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.JointStates()
    servo_cmd.name[:] = ["eef"]
    servo_cmd.effort[:] = force
    self._servo_eef_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.servo_eef_pos(pos)

Send continuous end effector width commands to the robot.

Effective for parallel two-finger end effector only.

Before calling this method, the robot should be in one of the "servo" states (SERVO_CART_TWIST, SERVO_CART_POSE, SERVO_JOINT_POS, SERVO_JOINT_VEL), otherwise the command would be ignored.

Parameters:

Name Type Description Default
pos list[float]

The end effector width commands in meters.

 required
Source code in airbot_py/arm.py 
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
@grpc_safe()
def servo_eef_pos(self, pos: Union[List[float], float]) -> None:
    """
    Send continuous end effector width commands to the robot.

    Effective for parallel two-finger end effector only.

    Before calling this method, the robot should be in one of the "servo"
    states (`SERVO_CART_TWIST`, `SERVO_CART_POSE`, `SERVO_JOINT_POS`,
    `SERVO_JOINT_VEL`), otherwise the command would be ignored.

    Args:
        pos (list[float]): The end effector width commands in meters.
    """
    # For backward compatibility
    if not isinstance(pos, list):
        pos = [pos]

    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.JointStates()
    servo_cmd.name[:] = ["eef"]
    servo_cmd.position[:] = pos
    self._servo_eef_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.servo_joint_pos(joint_pos)

Send continuous joint position commands to the robot.

The robot would follow the joint position commands, each of which representing the expected joint position of the arm.

Before calling this method, the robot should be in SERVO_JOINT_POS mode, otherwise the command would be ignored. Args: joint_pos (list[float]): The joint position commands in radian.

Source code in airbot_py/arm.py 
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
@grpc_safe()
def servo_joint_pos(self, joint_pos: List[float]) -> None:
    """
    Send continuous joint position commands to the robot.

    The robot would follow the joint position commands, each of
    which representing the expected joint position of the arm.

    Before calling this method, the robot should be in `SERVO_JOINT_POS`
    mode, otherwise the command would be ignored.
    Args:
        joint_pos (list[float]): The joint position commands in radian.
    """
    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.JointStates()
    servo_cmd.name[:] = [
        "joint1",
        "joint2",
        "joint3",
        "joint4",
        "joint5",
        "joint6",
    ]
    servo_cmd.position[:] = joint_pos
    self._servo_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.servo_joint_vel(joint_vel)

Send continuous joint velocity commands to the robot.

The robot would follow the joint velocity commands, each of which representing the expected joint velocity of the arm.

Before calling this method, the robot should be in SERVO_JOINT_VEL mode, otherwise the command would be ignored.

Parameters:

Name Type Description Default
joint_vel list[float]

The joint velocity commands in radian/s.

 required
Source code in airbot_py/arm.py 
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
@grpc_safe()
def servo_joint_vel(self, joint_vel: List[float]) -> None:
    """
    Send continuous joint velocity commands to the robot.

    The robot would follow the joint velocity commands, each of
    which representing the expected joint velocity of the arm.

    Before calling this method, the robot should be in `SERVO_JOINT_VEL`
    mode, otherwise the command would be ignored.

    Args:
        joint_vel (list[float]): The joint velocity commands in radian/s.
    """
    if self._servo_thread is None:
        self._servo_thread = threading.Thread(target=self._servo_cmd_gen)
        self._servo_thread.start()
    servo_cmd = types_pb2.JointStates()
    servo_cmd.name[:] = [
        "joint1",
        "joint2",
        "joint3",
        "joint4",
        "joint5",
        "joint6",
    ]
    servo_cmd.velocity[:] = joint_vel
    self._servo_cmd_queue.append(servo_cmd)
    self._servo_condition.release()
airbot_py.arm.AIRBOTArm.set_params(params)

Set parameters to the driver server.

Only bool, integer, double and string types are supported.

Parameters:

Name Type Description Default
params dict

A dictionary of the parameters to set.

 required

Return: params (dict): A dictionary of the parameters with the given keys and actual values after setting. The values are the same type as the input values.

Source code in airbot_py/arm.py 
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
@grpc_safe()
def set_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
    """
    Set parameters to the driver server.

    Only bool, integer, double and string types are supported.

    Args:
        params (dict): A dictionary of the parameters to set.
    Return:
        params (dict): A dictionary of the parameters with the given keys and actual \
            values after setting. The values are the same type as the input values.
    """
    if self._control_stub is None:
        return {}
    if len(params) == 0:
        logging.error("No parameter names provided.")
        return {}
    stamp = time.time_ns()
    request = arm_pb2.SetParamsRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id
    for key, value in params.items():
        request.keys.append(key)
        if isinstance(value, int):
            request.values.add(int32_val=value)
        elif isinstance(value, float):
            request.values.add(double_val=value)
        elif isinstance(value, str):
            request.values.add(string_val=value)
        elif isinstance(value, bool):
            request.values.add(bool_val=value)
        else:
            raise TypeError(f"Unsupported type: {type(value)}")
    response = self._control_stub.SetParams(request)
    return {
        k: getattr(v, v.WhichOneof("union"))
        for k, v in zip(response.keys, response.values)
    }
airbot_py.arm.AIRBOTArm.set_speed_profile(profile)

Set the speed profile of the robot.

Three speed profiles are available:

  • SpeedProfile.DEFAULT: Default speed profile.
  • SpeedProfile.SLOW: Slow speed profile.
  • SpeedProfile.FAST: Fast speed profile. Warning: This speed profile is experimental and may cause the robot to move too fast. It is dangerous not to make sure the robot is in a safe environment. Use at your own risk.

Parameters:

Name Type Description Default
profile SpeedProfile

The speed profile to set.

 required
Source code in airbot_py/arm.py 
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
@grpc_safe()
def set_speed_profile(self, profile: SpeedProfile):
    """
    Set the speed profile of the robot.

    Three speed profiles are available:

    * `SpeedProfile.DEFAULT`: Default speed profile.
    * `SpeedProfile.SLOW`: Slow speed profile.
    * `SpeedProfile.FAST`: Fast speed profile. \
        <span style="color: red">**Warning**: \
        This speed profile is experimental and may cause the robot to move too fast. \
        It is dangerous not to make sure the robot is in a safe environment. \
        Use at your own risk.</span>

    Args:
        profile (SpeedProfile): The speed profile to set.
    """
    if profile not in SpeedProfile:
        raise ValueError(f"Invalid speed profile: {profile}")
    elif profile == SpeedProfile.DEFAULT:
        self.set_params(
            {
                "servo_node.moveit_servo.scale.linear": 0.2,
                "servo_node.moveit_servo.scale.rotational": 0.2,
                "servo_node.moveit_servo.scale.joint": 0.1,
                "sdk_server.max_velocity_scaling_factor": 0.5,
                "sdk_server.max_acceleration_scaling_factor": 0.1,
            }
        )
    elif profile == SpeedProfile.SLOW:
        self.set_params(
            {
                "servo_node.moveit_servo.scale.linear": 0.05,
                "servo_node.moveit_servo.scale.rotational": 0.05,
                "servo_node.moveit_servo.scale.joint": 0.05,
                "sdk_server.max_velocity_scaling_factor": 0.1,
                "sdk_server.max_acceleration_scaling_factor": 0.02,
            }
        )
    elif profile == SpeedProfile.FAST:
        self.set_params(
            {
                "servo_node.moveit_servo.scale.linear": 10.0,
                "servo_node.moveit_servo.scale.rotational": 10.0,
                "servo_node.moveit_servo.scale.joint": 1.0,
                "sdk_server.max_velocity_scaling_factor": 1.0,
                "sdk_server.max_acceleration_scaling_factor": 0.5,
            }
        )
airbot_py.arm.AIRBOTArm.switch_mode(mode)

Switch the control mode of the robot.

The switching would not be effective if the sdk is in read-only state (when an read-write app is loaded).

Current supported mode:

  • RobotMode.PLANNING_POS: planning mode. A single target is sent to driver server, then a execution path is planned and execute. The target could be joint positions or end cartesian pose.
  • RobotMode.SERVO_CART_TWIST: servo mode in cartesian space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the cartesian twist commands, each of which representing the expected translational and rotational velocity of the end flange or the effecting point of the end effector.
  • RobotMode.SERVO_CART_POSE: servo mode in cartesian space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the cartesian pose commands, each of which representing the expected cartesian pose of the end flange or the effecting point of the end effector.
  • RobotMode.SERVO_JOINT_POS: servo mode in joint space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the joint position commands, each of which representing the expected joint position of the arm.
  • RobotMode.SERVO_JOINT_VEL: servo mode in joint space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the joint velocity commands, each of which representing the expected joint velocity of the arm.
  • RobotMode.GRAVITY_COMP: gravity compensation mode. In this mode, the robot would be in a free-drive state with gravity compensated. In this mode the robot would not follow any commands, but the robot could be dragged by external forces.

Parameters:

Name Type Description Default
mode RobotMode

The mode to switch to.

 required

Returns:

Name Type Description
result bool

True if the mode was switched successfully, False otherwise.
Source code in airbot_py/arm.py 
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
@grpc_safe()
def switch_mode(self, mode: RobotMode) -> bool:
    """
    Switch the control mode of the robot.

    The switching would not be effective if the sdk is in read-only state (when
    an read-write app is loaded).

    Current supported mode:

    * `RobotMode.PLANNING_POS`: planning mode. A single target is sent to
      driver server, then a execution path is planned and execute. The
      target could be joint positions or end cartesian pose.
    * `RobotMode.SERVO_CART_TWIST`: servo mode in cartesian space. Servo
      would require continuous commands to be sent to the driver server.
      In this mode, the robot would follow the cartesian twist commands,
      each of which representing the expected translational and rotational
      velocity of the end flange or the effecting point of the end effector.
    * `RobotMode.SERVO_CART_POSE`: servo mode in cartesian space. Servo
      would require continuous commands to be sent to the driver server.
      In this mode, the robot would follow the cartesian pose commands,
      each of which representing the expected cartesian pose of the end
      flange or the effecting point of the end effector.
    * `RobotMode.SERVO_JOINT_POS`: servo mode in joint space. Servo would
      require continuous commands to be sent to the driver server. In this
      mode, the robot would follow the joint position commands, each of
      which representing the expected joint position of the arm.
    * `RobotMode.SERVO_JOINT_VEL`: servo mode in joint space. Servo would
      require continuous commands to be sent to the driver server. In this
      mode, the robot would follow the joint velocity commands, each of
      which representing the expected joint velocity of the arm.
    * `RobotMode.GRAVITY_COMP`: gravity compensation mode. In this mode,
      the robot would be in a free-drive state with gravity compensated.
      In this mode the robot would not follow any commands, but the robot
      could be dragged by external forces.

    Args:
        mode (RobotMode): The mode to switch to.

    Returns:
        result (bool): True if the mode was switched successfully, False otherwise.
    """

    if self._control_stub is None:
        logging.error("Not connected to the server.")
        return False

    self._servo_cmd_queue.clear()
    self._servo_eef_cmd_queue.clear()
    self._servo_stop_event.set()
    if self._servo_thread is not None:
        self._servo_thread.join()
        self._servo_thread = None
    self._servo_stop_event.clear()
    self._servo_condition = threading.Semaphore(0)

    now = time.time_ns()
    request = arm_pb2.SetModeRequest()
    request.stamp.sec = int(now / 1e9)
    request.stamp.nanosec = int(now % 1e9)
    request.request_id = self.client_id
    request.component_names[:] = ["arm"]
    request.modes[:] = [mode.value]
    response = self._control_stub.SetMode(request)

    if response.modes[0] == mode.value:
        self.logger.info("Switched to %s successfully.", mode.name)
        return True
    else:
        self.logger.error("Failed to %s.", mode.name)
        return False
airbot_py.arm.AIRBOTArm.unload_app()

Unload the app from the driver server.

When an read-write app is unloaded, the SDK would enter read-write state, in which set methods are available. See [available states] (#airbot_py.arm--internal-states-of-the-driver)

Returns:

Name Type Description
result bool

True if the app was unloaded successfully, False otherwise.
Source code in airbot_py/arm.py 
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
@grpc_safe()
def unload_app(self) -> bool:
    """
    Unload the app from the driver server.

    When an read-write app is unloaded, the SDK would enter read-write state,
    in which set methods are available. See [available states]
    (#airbot_py.arm--internal-states-of-the-driver)

    Returns:
        result (bool): True if the app was unloaded successfully, False otherwise.
    """
    stamp = time.time_ns()
    request = utils_pb2.UnloadAppRequest()
    request.stamp.sec = int(stamp / 1e9)
    request.stamp.nanosec = int(stamp % 1e9)
    request.request_id = self.client_id

    response = self._utils_stub.UnloadApp(request)
    return response.ok

airbot_py.arm.RobotMode

Bases: Enum

Enum for the control mode of the arm.

  • PLANNING_POS: planning mode. A single target is sent to driver server, then a execution path is planned and execute. The target could be joint positions or end cartesian pose.
  • PLANNING_WAYPOINTS_PATH: planning mode. Perform linear interpolation between multiple waypoints in cartesian space, then execute the path without stopping.
  • PLANNING_WAYPOINTS: planning mode. Perform local planning between adjacent waypoints, join the planned paths then execute the path. Deceleration may occur near waypoints.
  • SERVO_CART_TWIST: servo mode in cartesian space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the cartesian twist commands, each of which representing the expected translational and rotational velocity of the end flange or the effecting point of the end effector.
  • SERVO_CART_POSE: servo mode in cartesian space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the cartesian pose commands, each of which representing the expected cartesian pose of the end flange or the effecting point of the end effector.
  • SERVO_JOINT_POS: servo mode in joint space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the joint position commands, each of which representing the expected joint position of the arm.
  • SERVO_JOINT_VEL: servo mode in joint space. Servo would require continuous commands to be sent to the driver server. In this mode, the robot would follow the joint velocity commands, each of which representing the expected joint velocity of the arm.
  • GRAVITY_COMP: gravity compensation mode. In this mode, the robot would be in a free-drive state with gravity compensated. In this mode the robot would not follow any commands, but the robot could be dragged by external forces.

airbot_py.arm.SpeedProfile

Bases: Enum

Enum for speed profile of the robot.

  • DEFAULT: The default speed profile.
  • SLOW: The slow speed profile.
  • FAST: The fast speed profile. WARNING: This speed profile is experimental and may cause the robot to move too fast and cause damage to the robot or the environment. Use at your own risk .

airbot_py.arm.State

Bases: Enum

Enum for the state of the driver service.

  • INIT: The driver service is initializing.
  • SHUTDOWN: The driver service is shutting down.
  • POWERON: The driver service is powered on and performing self-check.
  • IDLE: The driver service is idle and waiting for external SDK commands.
  • APPLOADING: The driver service is loading the application.
  • APPLOADED: The driver service has loaded the application and is ready to execute commands. When a read-write app is loaded, the robot is in read-only state and the SDK can only read the state of the robot.
  • ERROR: The driver service is in error state.

Examples

airbot_examples

Examples for AIRBOT Python SDK.

The examples are shipped with the AIRBOT Python SDK and can directly run on the command line. Running examples would require package airbot_py to be installed.

After launching the AIRBOT driver serivice (see step 1 and step 2 of introduction), the examples can be run with the following command:

python3 -m airbot_examples.<example_name> --port <port>

Available arguments for each examples could be examined by

python3 -m airbot_examples.<example_name> --help

Modules:

Name Description
app_load

Example of loading an internal app
app_unload

Example of unloading an internal app
get_end_pose

Example of getting end effector pose.
get_joint_pos

Example of getting joint position.
get_params

Example of getting joint position.
move_cart_pose

Example of moving the robot arm to a specified cartesian pose.
move_joint_pos

Example of moving the robot to a joint position
move_with_cart_waypoints

Example of moving the robot arm with waypoints.
move_with_joint_waypoints

Example of moving the robot arm with waypoints.
servo_cart_pose

Example of sending continuous cartesian pose commands to the robot arm.
servo_cart_twist

Example of sending continuous cartesian twist commands to the robot arm.
servo_joint_pos

Example of sending continuous joint position commands to the robot arm.
set_speed_profile

Example of sending continuous joint position commands to the robot arm.
switch_mode

Example of switching control mode.
task_follow

Make one arm follow the movement of another arm.
task_kbd_ctrl

Example application of controlling the robot arm using keyboard input.
task_swing

Example application: making the robot arm swing in a sinusoidal motion in joint space.
task_wipe

Example application: making the robot arm swing in a sinusoidal motion in cartesian space.
test_multiple_moves

Example of moving the robot to a joint position

airbot_examples.app_load

Example of loading an internal app

Functions:

Name Description
app_load

Load app according to the given app name

airbot_examples.app_load.app_load()

Load app according to the given app name

Source code in airbot_examples/app_load.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def app_load():
    """
    Load app according to the given app name
    """

    import argparse

    from airbot_py.arm import AIRBOTPlay

    parser = argparse.ArgumentParser(description="Load app example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        # Load record & replay app
        robot.load_app("record_replay_app/record_replay_app::RecordReplayApp")

airbot_examples.app_unload

Example of unloading an internal app

Functions:

Name Description
app_unload

Unload app according to the given app name

airbot_examples.app_unload.app_unload()

Unload app according to the given app name

Source code in airbot_examples/app_unload.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def app_unload():
    """
    Unload app according to the given app name
    """
    import argparse

    from airbot_py.arm import AIRBOTPlay

    parser = argparse.ArgumentParser(description="Load app example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        robot.unload_app()

airbot_examples.get_end_pose

Example of getting end effector pose.

The end effector pose along with robot state and control mode will be printed.

Functions:

Name Description
get_end_pose

Get end effector pose

airbot_examples.get_end_pose.get_end_pose()

Get end effector pose

Source code in airbot_examples/get_end_pose.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def get_end_pose():
    """
    Get end effector pose
    """
    import argparse
    import time

    from airbot_py.arm import AIRBOTPlay

    parser = argparse.ArgumentParser(description="Get arm infomation example 2")
    parser.add_argument(
        "-f",
        "--freq",
        type=int,
        default=10,
        help="Frequency of printing joint positions",
    )
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    args = parser.parse_args()

    idx = 0
    with AIRBOTPlay(port=args.port) as robot:
        product_info = robot.get_product_info()
        print("---------------------------------------------------------")
        print(f"Product name: {product_info['product_type']}")
        print(f"Serial number: {product_info['sn']}")
        print(f"Simulation mode: {product_info['is_sim']}")
        print(f"Using interfaces: {product_info['interfaces']}")
        print(f"Installed end effectors: {product_info['eef_types']}")

        while True:
            ####################################################
            # Get joint position and end effector position start
            pose = robot.get_end_pose()
            # Get joint position and end effector position end
            ####################################################
            if idx % args.freq == 0:
                server_state = robot.get_state().name
                control_mode = robot.get_control_mode().name
                print("---------------------------------------------------------")
                print(f"Server state: {server_state}")
                print(f"Control mode: {control_mode}")
                print(
                    "".join(
                        [f"{i:>8s}" for i in ["x", "y", "z", "qx", "qy", "qz", "qw"]]
                    )
                )
                print("---------------------------------------------------------")
            print(
                (
                    "".join([f"{i:+8.2f}" for i in pose[0]])
                    if pose is not None
                    else "Not received yet"
                ),
                end="",
            )
            print("".join([f"{i:+8.2f}" for i in pose[1]]) if pose is not None else "")
            time.sleep(1 / args.freq)
            idx += 1

airbot_examples.get_joint_pos

Example of getting joint position.

The joint position along with robot state and control mode will be printed.

Functions:

Name Description
get_joint_pos

Get joint position

airbot_examples.get_joint_pos.get_joint_pos()

Get joint position

Source code in airbot_examples/get_joint_pos.py 
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def get_joint_pos():
    """
    Get joint position
    """
    import argparse
    import math
    import time

    from airbot_py.arm import AIRBOTPlay

    parser = argparse.ArgumentParser(description="Get arm infomation example 1")
    parser.add_argument(
        "-f",
        "--freq",
        type=int,
        default=10,
        help="Frequency of printing joint positions",
    )
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "--radian",
        action="store_true",
        help="Print joint positions in radians instead of degrees",
    )
    args = parser.parse_args()

    idx = 0
    with AIRBOTPlay(port=args.port) as robot:
        product_info = robot.get_product_info()
        print("---------------------------------------------------------")
        print(f"Product name: {product_info['product_type']}")
        print(f"Serial number: {product_info['sn']}")
        print(f"Simulation mode: {product_info['is_sim']}")
        print(f"Using interfaces: {product_info['interfaces']}")
        print(f"Installed end effectors: {product_info['eef_types']}")

        while True:
            ####################################################
            # Get joint position and end effector position start
            pos = robot.get_joint_pos()
            eef_pos = robot.get_eef_pos()
            # Get joint position and end effector position end
            ####################################################
            if idx % args.freq == 0:
                server_state = robot.get_state().name
                control_mode = robot.get_control_mode().name
                print(
                    "----------------------------------------------------------------"
                )
                print(f"Server state: {server_state}")
                print(f"Control mode: {control_mode}")
                print(
                    " ".join([f"{'joint':>7s}{i+1}" for i in range(6)])
                    + f"{'end eff':>10s}"
                )
                print(
                    "----------------------------------------------------------------"
                )
            print(
                (
                    ", ".join(
                        [
                            (
                                f"{i / math.pi * 180:+7.2f}°"
                                if not args.radian
                                else f"{i:7.2f}"
                            )
                            for i in pos
                        ]
                    )
                    if pos is not None
                    else "None received yet"
                ),
                end="",
            )
            print(
                f"{eef_pos[0] * 100:8.2f} cm"
                if eef_pos is not None and len(eef_pos) > 0
                else ""
            )
            time.sleep(1 / args.freq)
            idx += 1

airbot_examples.get_params

Example of getting joint position.

The joint position along with robot state and control mode will be printed.

Functions:

Name Description
get_joint_pos

Get joint position

airbot_examples.get_params.get_joint_pos()

Get joint position

Source code in airbot_examples/get_params.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def get_joint_pos():
    """
    Get joint position
    """
    import argparse
    import math
    import time

    from airbot_py.arm import MODE_NAMES, STATE_NAMES, AIRBOTPlay

    parser = argparse.ArgumentParser(description="Get arm infomation example 1")
    parser.add_argument(
        "-f",
        "--freq",
        type=int,
        default=10,
        help="Frequency of printing joint positions",
    )
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "--radian",
        action="store_true",
        help="Print joint positions in radians instead of degrees",
    )
    args = parser.parse_args()

    with AIRBOTPlay(port=args.port) as robot:
        print(robot.get_params([]))

airbot_examples.move_cart_pose

Example of moving the robot arm to a specified cartesian pose.

Functions:

Name Description
move_cart_pose

Example of moving the robot arm to a specified cartesian pose.

airbot_examples.move_cart_pose.move_cart_pose()

Example of moving the robot arm to a specified cartesian pose.

Source code in airbot_examples/move_cart_pose.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def move_cart_pose():
    """
    Example of moving the robot arm to a specified cartesian pose.
    """
    import argparse
    import json

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-t",
        "--translation",
        type=json.loads,
        help="Target translation in the cartesian space, a 3-float array",
        default=[0.45, 0.20, 0.45],
    )
    parser.add_argument(
        "-r",
        "--orientation",
        type=json.loads,
        help="Target orientation (in quarternion) in the cartesian space, a 4-float array",
        default=[0.0, 0.0, 0.0, 1.0],
    )
    parser.add_argument(
        "-e",
        "--end-pos",
        type=float,
        help="Target end effector position, a float",
        default=0.0,
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_POS)
        robot.move_eef_pos([args.end_pos])
        robot.move_to_cart_pose([args.translation, args.orientation])
        robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.move_joint_pos

Example of moving the robot to a joint position

Functions:

Name Description
move_joint_pos

Move the robot to a joint position

airbot_examples.move_joint_pos.move_joint_pos()

Move the robot to a joint position

Source code in airbot_examples/move_joint_pos.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
def move_joint_pos():
    """
    Move the robot to a joint position
    """
    import argparse
    import json

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-j",
        "--joints",
        type=json.loads,
        help="Target joint positions, a 6-float array",
        default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    )
    parser.add_argument(
        "-e",
        "--end-pos",
        type=float,
        help="Target end effector position, a float",
        default=0.0,
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    args = parser.parse_args()

    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_POS)
        robot.move_eef_pos([args.end_pos])
        robot.move_to_joint_pos([float(i) for i in args.joints])
        robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.move_with_cart_waypoints

Example of moving the robot arm with waypoints.

Functions:

Name Description
move_with_cart_waypoints

Example of moving the robot arm with waypoints..

airbot_examples.move_with_cart_waypoints.move_with_cart_waypoints()

Example of moving the robot arm with waypoints..

Source code in airbot_examples/move_with_cart_waypoints.py 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def move_with_cart_waypoints():
    """
    Example of moving the robot arm with waypoints..
    """
    import argparse
    import json

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Waypoints example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-w",
        "--cart-waypoints",
        type=json.loads,
        help="Target waypoints as an array",
        default=[
            [[0.46, 0.0, 0.36], [0.0, 0.0, 0.0, 1.0]],
            [[0.46, 0.1, 0.26], [0.0, 0.0, 0.0, 1.0]],
            [[0.46, 0.0, 0.16], [0.0, 0.0, 0.0, 1.0]],
            [[0.46, -0.1, 0.26], [0.0, 0.0, 0.0, 1.0]],
        ],
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    parser.add_argument(
        "--path",
        action="store_true",
        help="Execute path without planning",
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        if args.path:
            robot.switch_mode(RobotMode.PLANNING_WAYPOINTS_PATH)
        else:
            robot.switch_mode(RobotMode.PLANNING_WAYPOINTS)
        robot.move_with_cart_waypoints(args.cart_waypoints)
        robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.move_with_joint_waypoints

Example of moving the robot arm with waypoints.

Functions:

Name Description
move_with_waypoints_path

Example of moving the robot arm with waypoints..

airbot_examples.move_with_joint_waypoints.move_with_waypoints_path()

Example of moving the robot arm with waypoints..

Source code in airbot_examples/move_with_joint_waypoints.py 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def move_with_waypoints_path():
    """
    Example of moving the robot arm with waypoints..
    """
    import argparse
    import json

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Waypoints example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-w",
        "--joint-waypoints",
        type=json.loads,
        help="Target translation in the cartesian space, a 3-float array",
        default=[
            [0.37, -0.6, 0.5, 0.132, -0.30, -0.13],
            [0.2, -2.0, 2.0, 0.0, 0.01, 0.0],
            [0.2, 0.1, 0.3, 0.0, 0.01, 0.0],
            [-0.2, 0.15, 0.0, 0.0, 0.01, 0.0],
        ],
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_WAYPOINTS)
        robot.move_with_joint_waypoints(args.joint_waypoints)
        robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.servo_cart_pose

Example of sending continuous cartesian pose commands to the robot arm.

Functions:

Name Description
servo_cart_pose

Example of sending continuous cartesian pose commands to the robot arm.

airbot_examples.servo_cart_pose.servo_cart_pose()

Example of sending continuous cartesian pose commands to the robot arm.

Source code in airbot_examples/servo_cart_pose.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def servo_cart_pose():
    """
    Example of sending continuous cartesian pose commands to the robot arm.
    """

    import argparse
    import json
    import time

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-t",
        "--translation",
        type=json.loads,
        help="Target translation in the cartesian space, a 3-float array",
        default=[0.45, 0.20, 0.45],
    )
    parser.add_argument(
        "-r",
        "--orientation",
        type=json.loads,
        help="Target orientation (in quarternion) in the cartesian space, a 4-float array",
        default=[0.0, 0.0, 0.0, 1.0],
    )
    parser.add_argument(
        "-e",
        "--end-pos",
        type=float,
        help="Target end effector position, a float",
        default=0.0,
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.SERVO_CART_POSE)
        try:
            while True:
                robot.servo_cart_pose([args.translation, args.orientation])
                robot.servo_eef_pos([args.end_pos])
                time.sleep(0.01)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.servo_cart_twist

Example of sending continuous cartesian twist commands to the robot arm.

Functions:

Name Description
servo_cart_twist

Example of sending continuous cartesian twist commands to the robot arm.

airbot_examples.servo_cart_twist.servo_cart_twist()

Example of sending continuous cartesian twist commands to the robot arm.

Source code in airbot_examples/servo_cart_twist.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
def servo_cart_twist():
    """
    Example of sending continuous cartesian twist commands to the robot arm.
    """

    import argparse
    import json
    import time

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-t",
        "--translation",
        type=json.loads,
        help="Target translation in the cartesian space, a 3-float array",
        default=[1.0, 0.0, 1.0],
    )
    parser.add_argument(
        "-r",
        "--rotation",
        type=json.loads,
        help="Target rotation in the cartesian space, a 3-float array",
        default=[0.0, 0.0, 0.0],
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )

    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.SERVO_CART_TWIST)
        try:
            while True:
                robot.servo_cart_twist([args.translation, args.rotation])
                time.sleep(0.01)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.servo_joint_pos

Example of sending continuous joint position commands to the robot arm.

Functions:

Name Description
servo_joint_pos

Example of sending continuous joint position commands to the robot arm.

airbot_examples.servo_joint_pos.servo_joint_pos()

Example of sending continuous joint position commands to the robot arm.

Source code in airbot_examples/servo_joint_pos.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def servo_joint_pos():
    """
    Example of sending continuous joint position commands to the robot arm.
    """

    import argparse
    import json
    import time

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-j",
        "--joints",
        type=json.loads,
        help="Target joint positions, a 6-float array",
        default=[0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
    )

    parser.add_argument(
        "-e",
        "--end-pos",
        type=float,
        help="Target end effector position, a float",
        default=0.0,
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )
    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.SERVO_JOINT_POS)
        try:
            while True:
                pos = [float(i) for i in args.joints]
                import math

                pos[4] += math.sin(time.time_ns() / 1e9 * 2 * math.pi / 2)
                robot.servo_joint_pos(pos)
                robot.servo_eef_pos([args.end_pos])
                time.sleep(0.01)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.set_speed_profile

Example of sending continuous joint position commands to the robot arm.

Functions:

Name Description
set_speed_profile

Example of sending continuous joint position commands to the robot arm.

airbot_examples.set_speed_profile.set_speed_profile()

Example of sending continuous joint position commands to the robot arm.

Source code in airbot_examples/set_speed_profile.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def set_speed_profile():
    """
    Example of sending continuous joint position commands to the robot arm.
    """

    import argparse
    import time

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )
    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_POS)
        try:
            robot.move_to_joint_pos([0, 0, 0, 0, 0, 0])
            time.sleep(1)
            robot.move_to_joint_pos([0, -2, 2, 0, 1, 0])
            time.sleep(1)
            robot.move_to_joint_pos([0, 0, 0, 0, 0, 0])
            time.sleep(1)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.switch_mode

Example of switching control mode.

Functions:

Name Description
switch_mode

Switch control mode according to the given mode

airbot_examples.switch_mode.switch_mode()

Switch control mode according to the given mode

Source code in airbot_examples/switch_mode.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def switch_mode():
    """
    Switch control mode according to the given mode
    """

    import argparse

    from airbot_py.arm import AIRBOTPlay, RobotMode

    parser = argparse.ArgumentParser(description="Switch control mode example")
    parser.add_argument(
        "-m",
        "--mode",
        type=str,
        choices=[
            "planning_pos",
            "planning_waypoints_pos",
            "servo_joint_pos",
            "servo_joint_vel",
            "servo_cart_pose",
            "servo_cart_twist",
            "gravity_comp",
        ],
        default="planning_pos",
        help="control mode to switch",
    )
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    args = parser.parse_args()

    with AIRBOTPlay(port=args.port) as robot:
        if args.mode == "planning_pos":
            robot.switch_mode(RobotMode.PLANNING_POS)
            print("Entered planning position mode")
        elif args.mode == "planning_waypoints_pos":
            robot.switch_mode(RobotMode.PLANNING_WAYPOINTS_POS)
            print("Entered planning waypointss mode")
        elif args.mode == "servo_joint_pos":
            robot.switch_mode(RobotMode.SERVO_JOINT_POS)
            print("Entered servo joint position mode")
        elif args.mode == "servo_joint_vel":
            raise RuntimeError("Servo joint velocity mode is not supported yet")
            # robot.switch_mode(RobotMode.SERVO_JOINT_VEL)
            # print("Entered servo joint velocity mode.")
        elif args.mode == "servo_cart_pose":
            robot.switch_mode(RobotMode.SERVO_CART_POSE)
            print("Entered servo cartesian pose mode.")
        elif args.mode == "servo_cart_twist":
            robot.switch_mode(RobotMode.SERVO_CART_TWIST)
            print("Entered servo cartesian twist mode.")
        elif args.mode == "gravity_comp":
            robot.switch_mode(RobotMode.GRAVITY_COMP)
            print("Entered gravity compensation mode.")
            print(
                "\x1b[1;32mGravity compensation mode. You can drag the end of the robot arm freely now.\x1b[0m"
            )
        else:
            print("Invalid mode")

airbot_examples.task_follow

Make one arm follow the movement of another arm.

Functions:

Name Description
follow

Follow the lead robot arm

airbot_examples.task_follow.follow()

Follow the lead robot arm

Source code in airbot_examples/task_follow.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def follow():
    """
    Follow the lead robot arm
    """
    import argparse
    import time

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Switch control mode example")
    parser.add_argument(
        "--lead-port", type=int, default=50051, help="Server port for arm to lead"
    )
    parser.add_argument(
        "--follow-port", type=int, default=50052, help="Server port for arm to follow"
    )

    args = parser.parse_args()
    if args.lead_port == args.follow_port:
        raise ValueError(
            "Lead port and follow port cannot be the same. Please use different ports."
        )

    with AIRBOTPlay(
        port=args.lead_port,
    ) as robot1, AIRBOTPlay(
        port=args.follow_port,
    ) as robot2:
        robot1.switch_mode(RobotMode.PLANNING_POS)
        if (
            sum(
                [
                    abs(i - j)
                    for i, j in zip(robot1.get_joint_pos(), robot2.get_joint_pos())
                ]
            )
            > 0.1
        ):
            robot2.switch_mode(RobotMode.PLANNING_POS)
            robot2.move_to_joint_pos(robot1.get_joint_pos())
            time.sleep(1)
        print("Lead robot arm is ready to follow.")
        robot1.switch_mode(RobotMode.GRAVITY_COMP)
        robot2.switch_mode(RobotMode.SERVO_JOINT_POS)
        robot2.set_speed_profile(SpeedProfile.FAST)
        try:
            while True:
                robot2.servo_joint_pos(robot1.get_joint_pos())
                robot2.servo_eef_pos(robot1.get_eef_pos() or [])
                time.sleep(0.01)
        finally:
            robot1.switch_mode(RobotMode.PLANNING_POS)
            robot2.switch_mode(RobotMode.PLANNING_POS)
            robot2.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.task_kbd_ctrl

Example application of controlling the robot arm using keyboard input.

Functions:

Name Description
task_kbd_ctrl

Example application of controlling the robot arm using keyboard input.

airbot_examples.task_kbd_ctrl.task_kbd_ctrl()

Example application of controlling the robot arm using keyboard input.

Source code in airbot_examples/task_kbd_ctrl.py 
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
def task_kbd_ctrl():
    """
    Example application of controlling the robot arm using keyboard input.
    """
    import argparse
    import curses
    import math
    import time

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-T",
        "--duration",
        type=float,
        default=10.0,
        help="Duration of the swing in seconds",
    )

    args = parser.parse_args()

    def main(stdscr):
        stdscr.nodelay(True)
        state = 1
        speed_profile = SpeedProfile.SLOW
        with AIRBOTPlay(port=args.port) as robot:
            robot.switch_mode(RobotMode.SERVO_CART_TWIST)
            robot.set_speed_profile(speed_profile)
            speed = 10
            try:
                while True:
                    key = stdscr.getch()
                    if key != -1:
                        if key == ord("\n"):
                            if speed_profile == SpeedProfile.SLOW:
                                speed_profile = SpeedProfile.DEFAULT
                            elif speed_profile == SpeedProfile.DEFAULT:
                                speed_profile = SpeedProfile.SLOW
                            robot.set_speed_profile(speed_profile)
                        if key == ord(" "):
                            if state == 1:
                                robot.switch_mode(RobotMode.SERVO_JOINT_VEL)
                                state = 0
                            elif state == 0:
                                robot.switch_mode(RobotMode.SERVO_CART_TWIST)
                                state = 1
                        if state == 0:
                            if key == ord("1"):
                                robot.servo_joint_vel([speed, 0.0, 0.0, 0.0, 0.0, 0.0])
                            if key == ord("2"):
                                robot.servo_joint_vel([-speed, 0.0, 0.0, 0.0, 0.0, 0.0])
                            if key == ord("3"):
                                robot.servo_joint_vel([0.0, speed, 0.0, 0.0, 0.0, 0.0])
                            if key == ord("4"):
                                robot.servo_joint_vel([0.0, -speed, 0.0, 0.0, 0.0, 0.0])
                            if key == ord("5"):
                                robot.servo_joint_vel([0.0, 0.0, speed, 0.0, 0.0, 0.0])
                            if key == ord("6"):
                                robot.servo_joint_vel([0.0, 0.0, -speed, 0.0, 0.0, 0.0])
                            if key == ord("7"):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, speed, 0.0, 0.0])
                            if key == ord("8"):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, -speed, 0.0, 0.0])
                            if key == ord("9"):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, 0.0, speed, 0.0])
                            if key == ord("0"):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, 0.0, -speed, 0.0])
                            if key == ord("-"):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, 0.0, 0.0, speed])
                            if key == ord("="):
                                robot.servo_joint_vel([0.0, 0.0, 0.0, 0.0, 0.0, -speed])
                        elif state == 1:
                            if key == ord("a"):
                                robot.servo_cart_twist(
                                    [[0.0, +speed, 0.0], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("d"):
                                robot.servo_cart_twist(
                                    [[0.0, -speed, 0.0], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("w"):
                                robot.servo_cart_twist(
                                    [[+speed, 0.0, 0.0], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("s"):
                                robot.servo_cart_twist(
                                    [[-speed, 0.0, 0.0], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("q"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, +speed], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("e"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, -speed], [0.0, 0.0, 0.0]]
                                )
                            if key == ord("o"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [+speed, 0.0, 0.0]]
                                )
                            if key == ord("u"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [-speed, 0.0, 0.0]]
                                )
                            if key == ord("i"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [0.0, +speed, 0.0]]
                                )
                            if key == ord("k"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [0.0, -speed, 0.0]]
                                )
                            if key == ord("j"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [0.0, 0.0, +speed]]
                                )
                            if key == ord("l"):
                                robot.servo_cart_twist(
                                    [[0.0, 0.0, 0.0], [0.0, 0.0, -speed]]
                                )
                        if key == ord("\t"):
                            robot.switch_mode(RobotMode.PLANNING_POS)
                            robot.move_to_joint_pos(
                                [
                                    0.0,
                                    10 / 360.0 * 2 * math.pi,
                                    -5 / 360.0 * 2 * math.pi,
                                    -90 / 360.0 * 2 * math.pi,
                                    0.0,
                                    90 / 360.0 * 2 * math.pi,
                                ]
                            )
                            time.sleep(0.5)
                            robot.switch_mode(RobotMode.SERVO_CART_TWIST)
                            state = 1
                    if key == ord("["):
                        robot.servo_eef_pos([0.00])
                    if key == ord("]"):
                        robot.servo_eef_pos([0.07])
                    if key == ord("z"):  # 按 'q' 退出
                        break
            finally:
                robot.set_speed_profile(SpeedProfile.DEFAULT)

    curses.wrapper(main)

airbot_examples.task_swing

Example application: making the robot arm swing in a sinusoidal motion in joint space.

Functions:

Name Description
task_swing

Make the robot arm swing in a sinusoidal motion in joint space.

airbot_examples.task_swing.task_swing()

Make the robot arm swing in a sinusoidal motion in joint space.

Source code in airbot_examples/task_swing.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
def task_swing():
    """
    Make the robot arm swing in a sinusoidal motion in joint space.
    """

    import argparse
    import math
    import time

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-T",
        "--duration",
        type=float,
        default=10.0,
        help="Duration of the swing in seconds",
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )
    args = parser.parse_args()

    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_POS)
        robot.move_to_joint_pos([0, -math.pi / 4, math.pi / 4, 0.0, 0.0, 0.0])
        time.sleep(0.5)
        robot.switch_mode(RobotMode.SERVO_JOINT_POS)
        start = time.time_ns()
        try:
            while True:
                timed_coef = math.sin(
                    (time.time_ns() - start - 0.5 * 1e9)
                    / 1e9
                    * 2
                    * math.pi
                    / args.duration
                )
                joint_pos = [
                    math.pi / 2 * timed_coef,
                    -math.pi / 4 - math.pi / 4 * timed_coef,
                    math.pi / 4 + math.pi / 4 * timed_coef,
                    0,
                    0,
                    0,
                ]
                robot.servo_joint_pos(joint_pos)
                robot.servo_eef_pos([(1 - timed_coef) * 0.07 / 2])
                time.sleep(0.01)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.task_wipe

Example application: making the robot arm swing in a sinusoidal motion in cartesian space.

Functions:

Name Description
task_wipe

Example application: making the robot arm swing in a sinusoidal motion in joint space.

airbot_examples.task_wipe.task_wipe()

Example application: making the robot arm swing in a sinusoidal motion in joint space.

Source code in airbot_examples/task_wipe.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
def task_wipe():
    """
    Example application: making the robot arm swing in a sinusoidal motion in joint space.
    """

    import argparse
    import json
    import math
    import time

    print(
        "\x1b[1;33mThe robot arm is about to be move. Please make sure no obstacles exist in the surrounding environment.\x1b[0m"
    )
    input("\x1b[1;35mPress Enter to continue...\x1b[0m")
    print("\x1b[1;32mPress Ctrl+C to stop...\x1b[0m")

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    parser = argparse.ArgumentParser(description="Servo example")
    parser.add_argument(
        "-p", "--port", type=int, default=50051, help="Port to connect to the server"
    )
    parser.add_argument(
        "-T",
        "--duration",
        type=float,
        default=2.0,
        help="Duration of the swing in seconds",
    )
    parser.add_argument(
        "-S",
        "--speed",
        choices=["slow", "fast", "default"],
        default="default",
        help="Speed profile for the robot arm",
    )
    args = parser.parse_args()
    with AIRBOTPlay(port=args.port) as robot:
        if args.speed == "slow":
            robot.set_speed_profile(SpeedProfile.SLOW)
        elif args.speed == "fast":
            robot.set_speed_profile(SpeedProfile.FAST)
        else:
            robot.set_speed_profile(SpeedProfile.DEFAULT)
        robot.switch_mode(RobotMode.PLANNING_POS)
        robot.move_to_cart_pose([[0.35, 0.0, 0.50], [0, 0, 0, 1]])
        time.sleep(0.5)
        robot.switch_mode(RobotMode.SERVO_JOINT_POS)

        robot.switch_mode(RobotMode.SERVO_CART_POSE)
        start = time.time_ns()
        try:
            while True:
                now = time.time_ns() - start - 0.5 * 1e9
                pose = [
                    [
                        0.35,
                        0.15 * math.sin(now / 1e9 * 2 * math.pi / args.duration),
                        0.50,
                    ],
                    [0, 0, 0, 1],
                ]
                robot.servo_cart_pose(pose)
                robot.servo_eef_pos([0])
                time.sleep(0.01)
        finally:
            robot.set_speed_profile(SpeedProfile.DEFAULT)

airbot_examples.test_multiple_moves

Example of moving the robot to a joint position

Functions:

Name Description
move_joint_pos

Move the robot to a joint position

airbot_examples.test_multiple_moves.move_joint_pos()

Move the robot to a joint position

Source code in airbot_examples/test_multiple_moves.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def move_joint_pos():
    """
    Move the robot to a joint position
    """
    import argparse
    import json

    from airbot_py.arm import AIRBOTPlay, RobotMode, SpeedProfile

    with AIRBOTPlay() as robot:
        print(robot.get_product_info())
        while True:
            robot.switch_mode(RobotMode.PLANNING_POS)
            robot.set_speed_profile(SpeedProfile.FAST)
            robot.move_eef_pos([0.035])
            robot.move_to_joint_pos([0, 0, 0, 0, 0, 0])
            robot.move_eef_pos([0.07])
            robot.move_to_joint_pos([0, 0, 0, 0, 1, 0])
            robot.move_eef_pos([0.035])
            robot.move_to_joint_pos([0, 0, 0, 0, -1, 0])
            robot.move_eef_pos([0.0])
            robot.move_to_joint_pos([0, 0, 0, 0, 0, 0])
            robot.set_speed_profile(SpeedProfile.DEFAULT)

Examples

Keyboard Control

With airbot_py package installed and the driver server running, you can control the robot arm using keyboard inputs. This is particularly useful for testing and demonstration purposes.

Run with the following command:

python3 -m airbot_examples.task_kbd_ctrl

This manual explains the key mappings for controlling the robot arm using the keyboard. Each key corresponds to a specific action or mode for controlling the robot.

Key Mappings

General Controls

Key Action
Enter Toggle between SLOW and DEFAULT speed profiles.
Space Toggle between SERVO_JOINT_VEL and SERVO_CART_TWIST modes.
Tab Switch to PLANNING_POS mode and move robot to the starting position.
[ Close the gripper.
] Open the gripper.
z Exit the program.

Joint Velocity Control

When in SERVO_JOINT_VEL mode, the following keys control the robot's joint velocities:

Key Action
1 Move the joint #1 forward (+speed).
2 Move the joint #1 backward (-speed).
3 Move the joint #2 forward (+speed).
4 Move the joint #2 backward (-speed).
5 Move the joint #3 forward (+speed).
6 Move the joint #3 backward (-speed).
7 Move the joint #4 forward (+speed).
8 Move the joint #4 backward (-speed).
9 Move the joint #5 forward (+speed).
0 Move the joint #5 backward (-speed).
- Move the joint #6 forward (+speed).
= Move the joint #6 backward (-speed).

Cartesian Twist Control

When in SERVO_CART_TWIST mode, the following keys control the robot's movement in Cartesian space:

Key Action
a Move the robot arm left along the Y-axis (+speed).
d Move the robot arm right along the Y-axis (-speed).
w Move the robot arm forward along the X-axis (+speed).
s Move the robot arm backward along the X-axis (-speed).
q Move the robot arm up along the Z-axis (+speed).
e Move the robot arm down along the Z-axis (-speed).
o Move the robot arm right along the X-axis (+speed).
u Move the robot arm left along the X-axis (-speed).
i Move the robot arm up along the Y-axis (+speed).
k Move the robot arm down along the Y-axis (-speed).
j Move the robot arm towards the user along the Z-axis (+speed).
l Move the robot arm away from the user along the Z-axis (-speed).

Notes

  • Ensure there are no obstacles around the robot before starting the control process.
  • The robot arm can be stopped at any time by pressing Ctrl+C.