Aubo SDK

Overview

Aubo SDK provides a complete set of interfaces for controlling and managing robotic systems. The SDK uses a layered architecture design, with Main Entrance as the main entry point providing access to various functional modules.

Table of Contents

• Quick Start
• SDK Architecture
• Core Modules
• Usage Examples
• Namespace
• Error Handling
• Supported Programming Languages

Quick Start

Basic Usage Flow

// 1. Get the main API interface
auto rpc_cli = std::make_shared<RpcClient>();
 
// 2. Get robot list
auto robot_names = rpc_cli->getRobotNames();
auto robot_name = robot_names.front();
 
// 3. Get robot interface
auto robot = rpc_cli->getRobotInterface(robot_name);
 
// 4. Get specific functional modules
auto motion = robot->getMotionControl();
auto state = robot->getRobotState();

SDK Architecture

Layer Structure

AuboApi
├── System-level Interfaces
│   ├── SystemInfo
│   ├── RuntimeMachine
│   ├── RegisterControl
│   ├── Math
│   ├── SyncMove
│   └── Trace
├── Device Interfaces
│   ├── RobotInterface
│   │   ├── RobotConfig
│   │   ├── MotionControl
│   │   ├── ForceControl
│   │   ├── IoControl
│   │   ├── RobotAlgorithm
│   │   ├── RobotManage
│   │   └── RobotState
│   ├── AxisInterface
│   └── GripperInterface
└── Communication Interfaces
    ├── Socket
    └── Serial

Core Modules

Function	Interface	File	Description
Robot Motion	MotionControl	robot/motion_control.h	Path planning, joint motion, linear motion, circular motion control, velocity and acceleration parameter settings, equivalent radius configuration
Robot Configuration	RobotConfig	robot/robot_config.h	Robot body parameter management, tool coordinate system (TCP) settings, user coordinate system settings, load and center of mass parameter configuration
Robot State	RobotState	robot/robot_state.h	Real-time joint angle and end-effector pose query, robot operating status retrieval, error and exception status query
Robot Management	RobotManage	robot/robot_manage.h	Robot power-on, enable, power-off control, emergency stop, pause and resume operations, operating mode switching
IO Control	IoControl	robot/io_control.h	Digital IO read/write, analog IO read/write, IO parameter and mode configuration
Force Control	ForceControl	robot/force_control.h	Force/torque sensor configuration, force control motion interface, impedance control and compliant control
Algorithm Utilities	RobotAlgorithm	robot/robot_algorithm.h	Coordinate system transformation calculation, forward/inverse kinematics solving, collision detection and space constraint judgment
External Axis	AxisInterface	axis_interface.h	External axis power-on and startup management, external axis motion control, external axis installation pose and calibration settings
Gripper	GripperInterface	gripper_interface.h	Gripper device scanning and adding, gripper connection and status management, gripper open/close and action control
System Information	SystemInfo	system_info.h	Controller software version query, hardware information retrieval, overall system operating status
Runtime	RuntimeMachine	runtime_machine.h	Task creation and deletion, script execution and management, breakpoint settings and program control
Register	RegisterControl	register_control.h	Read/write operations for boolean registers, integer registers, and floating-point registers
Math Utilities	Math	math.h	Matrix operations, quaternion operations, coordinate and pose transformation related math tools
Network Communication	Socket	socket.h	TCP client communication interface, network connection and session management
Serial Communication	Serial	serial.h	Serial data read/write, baud rate and communication parameter configuration
Sync Motion	SyncMove	sync_move.h	Multi-device sync motion control, sync timing management, external axis axis group management
Alert Log	Trace	trace.h	Alert information query, system log recording and export

Usage Examples

Get Robot State

auto rpc_cli = std::make_shared<RpcClient>();
auto robot = rpc_cli->getRobotInterface("rob1");
auto state = robot->getRobotState();
 
// Get joint angles
auto joint_angles = state->getJointState();

Execute Motion

auto motion = robot->getMotionControl();
 
// Set motion parameters
motion->setEqradius(0.8);
 
// Execute joint motion
std::vector<double> target_pose = {0, -1.57, 1.57, 0, 0, 0};
motion->moveJoint(target_pose, 0.5, 0.5);

Control IO

auto io = robot->getIoControl();
 
// Set digital output
io->setStandardDigitalOutput(0, true);
 
// Read digital input
bool input_state = io->getStandardDigitalInput(0);

Namespace

All interfaces are defined in the following namespaces:

namespace arcs {
namespace common_interface {
    // All interface definitions
}
}

Error Handling

Most interface methods return an integer error code, where 0 indicates success and negative numbers indicate errors. Some interfaces may throw AuboException exceptions.

Supported Programming Languages

• C++
• Python
• Lua
• JSON-RPC

Related Files

• type_def.h - Type definitions
• global_config.h - Global configuration
• error_stack/ - Error handling related