联想晨星SDK文档

English

中文

English

中文

Appearance

Common Task Service Interface ​

FunctionC++PythonC#Java
Create Task✔✔✔✔
Dry Run Task✔✔✔✔
Execute Task✔✔✔✔
Pause Task✔✔✔✔
Resume Task✔✔✔✔
Stop Task✔✔✔✔
Delete Task✔✔✔✔
Get Task List✔✔✔✔
Listen Task Status✔✔✔✔
Unregister Task Status✔✔✔✔
Listen Task Script✔-✔✔
Unregister Task Script✔-✔✔

CreateTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse CreateTask(string taskId, string scriptContent, int id = 301, int timeoutMs = 5000)
  • C++: TaskOperationReply createTask(const std::string &task_id, const std::string &script_content)
  • Python: async def create_task(task_id: str, script_content: str, timeout: int = 30, wait_timeout: float = 10.0) -> dict
  • Java: void CreateTask(String taskId, String scriptContent)

Function Description ​

Creates a common task.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringRequiredTask identifier
scriptContentstringRequiredTask script content
timeoutintOptionalTimeout (supported by some languages)

Return Value ​

LanguageReturn TypeDescription
C#RobotTaskOperationResponseContains success(bool) and message(string)
C++TaskOperationReplyContains success(bool) and message(string)
PythondictContains success(bool) and message(string)
JavavoidNo return value

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.CreateTask("task_001", "print('hello'");
if (result.success)
{
    Debug.Log($"✓ Task created successfully: {result.message}");
}
else
{
    Debug.LogError($"✗ Task creation failed: {result.message}");
}
python
# Python
from daystar_sdk import WebSocketRobotClient

# Init Client
with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.create_task("task_001", "print('hello')")
    if success:
        print("Task created successfully, result：", result_dict)
    else:
        print("Task creation failed, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = task.CreateTask("task001", "print('Hello from robot task')");
if (!response.success) {
    logger.error("Create task failed: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.createTask("task_001", "print('hello')");
if (result.success)
{
    std::cout << "✓ Task created successfully: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task creation failed: " << result.message << std::endl;
}

Task Script Content Example ​

The following example is a navigation task. You can also add tasks such as gimbal control, manipulation, and charging docking. For a complete introduction and examples of common task scripts, please visit http://im.daystar.cloud:8000/

python
from daystar_api.lowlevel_skills import *
from daystar_api.lowlevel_skills import NavCompleteEvent, NavFailedEvent, NavProgressEvent

# Use this for outdoor waypoints
travel_params_road = MsgTravelParams() # Outdoor waypoint navigation parameters, open obstacle avoidance, ignore orientation
travel_params_road.speed_mode = 2  # HIGH speed
travel_params_road.distance_tolerance = 0.3  # 30cm distance tolerance
travel_params_road.gait = 2  # TROT gait
travel_params_road.disable_body_obstacle_avoidance = False  # Enable obstacle avoidance
travel_params_road.ignore_final_yaw = True  # Ignore target orientation
travel_params_road.path_following_mode = 1  # Default line following
travel_params_road.direction_constraint = 1  # No direction constraint

# Use this for stair endpoints
travel_params_stair = MsgTravelParams() # Stair navigation parameters, close obstacle avoidance, ignore orientation
travel_params_stair.speed_mode = 2  # LOW speed
travel_params_stair.distance_tolerance = 0.3  # 30cm distance tolerance
travel_params_stair.gait = 2  # TROT gait
travel_params_stair.disable_body_obstacle_avoidance = True  # Disable obstacle avoidance
travel_params_stair.ignore_final_yaw = True  # Ignore target orientation
travel_params_stair.path_following_mode = 1  # Default line following
travel_params_stair.direction_constraint = 1  # No direction constraint


def nav_complete_callback(event : NavCompleteEvent):
    print(f"target: {event.target}")

def nav_failed_callback(event: NavFailedEvent):
    print(f"✗ Navigation failed: {event.error_msg}")

def nav_progress_callback(event : NavProgressEvent):
    print(f"distance : {event.distance_remaining}")

navigation_to_location(location='pointD', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)
navigation_to_location(location='pointC', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)
navigation_to_location(location='pointE', travel_params=travel_params_road, complete_callback=nav_complete_callback, failed_callback=nav_failed_callback, progress_callback=nav_progress_callback)

ExecuteTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse ExecuteTask(string taskId, string scriptContent = null, int id = 302, int timeoutMs = 5000)
  • C++: TaskOperationReply executeTask(const std::string &task_id, const std::string &script_content = "")
  • Python: async def execute_task(task_id: str = "", script_content: str = "", timeout: int = 60, wait_timeout: float = 15.0) -> dict
  • Java: void ExecuteTask(String taskId, String scriptContent, int timeout)

Function Description ​

Executes a common task. If taskId is not empty, it executes an existing task. If taskId is empty and scriptContent is not empty, it dry runs the script.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringOptionalTask identifier (required for existing tasks)
scriptContentstringOptionalScript content (required for dry run)
timeoutintOptionalTimeout

Return Value ​

Same as CreateTask, Java returns void.

Code Example ​

csharp
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

// C# Execute an existing task
var result_1 = _robotTaskClient.ExecuteTask("task_001");
// C# Test run script
var result_2 = _robotTaskClient.ExecuteTask("", "print('test')");
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.execute_task(task_id="task_001")
    if success:
        print("Task created successfully, result：", result_dict)
    else:
        print("Task creation failed, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = task.ExecuteTask("task_001", "", 0);
if (!response.success) {
    logger.error("Execute task failed: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.executeTask("task_001");
if (result.success)
{
    std::cout << "✓ Task executed: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task execution failed: " << result.message << std::endl;
}

Notes ​

  1. Before executing a task, ensure that the current navigation status is localization successful and the current position can be obtained.
  2. How to verify? You can check it in the SDK visualization tool. For detailed usage, refer to the chapter Application Development - Visualization Tool.

PauseTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse PauseTask(string taskId, int id = 304, int timeoutMs = 5000)
  • C++: TaskOperationReply pauseTask(const std::string &task_id)
  • Python: async def pause_task(task_id: str, wait_timeout: float = 6.0) -> dict
  • Java: void PauseTask(String taskId)

Function Description ​

Pauses the specified task.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringRequiredTask identifier

Return Value ​

Same as CreateTask, Java returns void.

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.PauseTask("task_001");
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.pause_task(task_id="task_001")
    if success:
        print("Task paused successfully, result：", result_dict)
    else:
        print("Task paused failed, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.PauseTask("task_001");
if (!response.success) {
    logger.error("Failed to pause task: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.pauseTask("task_001");
if (result.success)
{
    std::cout << "✓ Task paused: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to pause the task: " << result.message << std::endl;
}

ResumeTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse ResumeTask(string taskId, int id = 305, int timeoutMs = 5000)
  • C++: TaskOperationReply resumeTask(const std::string &task_id)
  • Python: async def resume_task(task_id: str, wait_timeout: float = 6.0) -> dict
  • Java: void ResumeTask(String taskId)

Function Description ​

Resumes a paused task.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringRequiredTask identifier

Return Value ​

Same as CreateTask, Java returns void.

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.ResumeTask("task_001");
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.resume_task(task_id="task_001")
    if success:
        print("Task resumed successfully, result：", result_dict)
    else:
        print("Task resumed failed, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.ResumeTask("task_001");
if (!response.success) {
    logger.error("Task resumed failed: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.resumeTask("task_001");
if (result.success)
{
    std::cout << "✓ Task resumed: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Task resumed failed: " << result.message << std::endl;
}

StopTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse StopTask(string taskId, int id = 306, int timeoutMs = 5000)
  • C++: TaskOperationReply stopTask(const std::string &task_id)
  • Python: async def stop_task(task_id: str = "", wait_timeout: float = 10.0) -> dict
  • Java: void StopTask(String taskId)

Function Description ​

Stops the specified task.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringRequiredTask identifier

Return Value ​

Same as CreateTask, Java returns void.

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.StopTask("task_001");
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.stop_task(task_id="task_001")
    if success:
        print("Task stopped successfully, result：", result_dict)
    else:
        print("Failed to stop the task, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.StopTask("task_001");
if (!response.success) {
    logger.error("Failed to stop the task: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.stopTask("task_001");
if (result.success)
{
    std::cout << "✓ Task stopped: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to stop the task: " << result.message << std::endl;
}

DeleteTask ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse DeleteTask(string taskId, int id = 307, int timeoutMs = 5000)
  • C++: TaskOperationReply deleteTask(const std::string &task_id)
  • Python: async def delete_task(task_id: str, wait_timeout: float = 8.0) -> dict
  • Java: void DeleteTask(String taskId)

Function Description ​

Deletes the specified task.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
taskIdstringRequiredTask identifier

Return Value ​

Same as CreateTask, Java returns void.

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.DeleteTask("task_001");
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    success, result_dict = await client.delete_task(task_id="task_001")
    if success:
        print("Task deleted successfully, result：", result_dict)
    else:
        print("Failed to delete task, error message：", result_dict)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
ServiceOperationResponse response = robot.DeleteTask("task_001");
if (!response.success) {
    logger.error("Failed to delete task: " + response.message);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.deleteTask("task_001");
if (result.success)
{
    std::cout << "✓ Task deleted: " << result.message << std::endl;
}
else
{
    std::cout << "✗ Failed to delete the task: " << result.message << std::endl;
}

GetAllTasks ​

Function Prototypes ​

  • C#: RobotTaskOperationResponse GetAllTasks(int id = 308, int timeoutMs = 5000)
  • C++: GetAllTasksReply getAllTasks()
  • Python: async def get_all_tasks(wait_timeout: float = 8.0) -> dict
  • Java: List<String> GetAllTasks()

Function Description ​

Retrieves the list of all created tasks.

Parameters ​

None

Return Value ​

LanguageReturn TypeDescription
C#RobotTaskOperationResponseParsed to get task list
C++GetAllTasksReplyContains std::vector<std::string> tasks
PythondictContains task_ids list
JavaList<String>Returns task ID list directly

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

var result = _robotTaskClient.GetAllTasks();
if (result.success)
{
    string taskList = "Task List:\n";
    if (result.taskIds != null && result.taskIds.Length > 0)
    {
        for (int i = 0; i < result.taskIds.Length; i++)
        {
            taskList += $"{i + 1}. {result.taskIds[i]}\n";
        }
    }
    else
    {
        taskList += "No tasks";
    }
    
    Debug.Log($"✓ Got all tasks: {result.message}");
}
else
{
    Debug.LogError($"✗ Failed to get all tasks: {result.message}");
}
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    result = await client.get_all_tasks()
    print(f"result: {result}")
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
List<String> tasks = task.GetAllTasks();
for (String taskId : tasks) {
    System.out.println("Task: " + taskId);
}
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
auto result = sysb.getAllTasks();
if (result.success)
{
    std::cout << "✓ Task List(" << result.task_ids.size() << "task):" << std::endl;
    for (size_t i = 0; i < result.task_ids.size(); i++)
    {
        std::cout << "  " << (i + 1) << ". ID: " << result.task_ids[i] << std::endl;
    }
}
else
{
    std::cout << "✗ Failed to get task list: " << result.message << std::endl;
}

RegisterTaskStatusCallback ​

Function Prototypes ​

  • C#: bool RegisterTaskStatusCallback(Action<object> callback)
  • C++: void setTaskStatusCallback(std::function<void(const TaskStatus &)> callback)
  • Python: async def register_task_status_callback(callback: Callable)
  • Java: void RegisterTaskStatusFeedback(Consumer<TaskStatus> callback)

Function Description ​

Registers a callback to listen for task status updates.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
callbackfunctionRequiredCallback function, receives the task status object

Return Value ​

  • C#: bool (success)
  • Python: bool (success)
  • C++/Java: void

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

void OnTaskStatusUpdate(object statusData)
{
    try
    {
        Debug.Log($"[TaskStatusCallback] Received task status update: {statusData}");
        
        // Attempt to parse task status data
        string statusText = "【Task Status Update】\n";
        
        if (statusData == null)
        {
            statusText += "Status data is null";
        }
        else
        {
            // Parse status data using reflection or type conversion
            var dataType = statusData.GetType();
            statusText += $"Data Type: {dataType.Name}\n";
            statusText += $"Details: {statusData}\n";
            
            // Attempt to get common fields
            try
            {
                var taskIdProp = dataType.GetProperty("task_id") ?? dataType.GetProperty("taskId");
                var statusProp = dataType.GetProperty("status");
                var messageProp = dataType.GetProperty("message");
                var progressProp = dataType.GetProperty("progress");
                
                if (taskIdProp != null)
                {
                    var taskId = taskIdProp.GetValue(statusData);
                    statusText += $"Task ID: {taskId}\n";
                }
                
                if (statusProp != null)
                {
                    var status = statusProp.GetValue(statusData);
                    statusText += $"Status: {status}\n";
                }
                
                if (messageProp != null)
                {
                    var message = messageProp.GetValue(statusData);
                    statusText += $"Message: {message}\n";
                }
                
                if (progressProp != null)
                {
                    var progress = progressProp.GetValue(statusData);
                    statusText += $"Progress: {progress}\n";
                }
            }
            catch (Exception parseEx)
            {
                Debug.LogWarning($"Failed to parse task status fields: {parseEx.Message}");
            }
        }
        
    }
    catch (Exception ex)
    {
        Debug.LogError($"Error in OnTaskStatusUpdate: {ex.Message}\n{ex.StackTrace}");
    }
}

bool success = _robotTaskClient.RegisterTaskStatusCallback(OnTaskStatusUpdate);
if (success)
{
    Debug.Log("✓ Task status callback registered successfully");
}
else
{
    Debug.LogError("✗ Failed to register task status callback");
}
python
# Python
from daystar_sdk import WebSocketRobotClient

async def on_status(data):
    print(data)

with WebSocketRobotClient(host='localhost', port=5252) as client:
    await client.register_task_status(on_status)
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.RegisterTaskStatusFeedback(new Consumer<TaskStatus>() {
    @Override
    public void accept(TaskStatus feedback) {
        logger.info("TaskStatusFeedback with id: " + feedback.task_id + 
                    ", State: " + feedback.state +
                    ", State Name: " + feedback.state_name +
                    ", Progress: " + feedback.progress + 
                    ", Current Operation: " + feedback.current_operation +
                    ", Error Message: " + feedback.error_message +
                    ", Start Time: " + feedback.start_time +
                    ", Last Update: " + feedback.last_update +
                    ", Timeout Seconds: " + feedback.timeout_seconds);
    }
});
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setTaskStatusCallback([](const Lenovo::Daystar::TaskStatus &task_status) {
    std::cout << "[Callback] Task status update: ID=" << task_status.task_id 
        << ", Status=" << task_status.status 
        << ", Message=" << task_status.message << std::endl;
});
std::cout << "✓ Task status callback registered" << std::endl;

RegisterScriptOutputCallback ​

Function Prototypes ​

  • C#: bool RegisterScriptOutputCallback(Action<object> callback)
  • C++: void setScriptOutputCallback(std::function<void(const ScriptOutput &)> callback)
  • Java: void registerScriptOutputFeedback(Consumer<ScriptOutput> callback)
  • Python: N/A

Function Description ​

Registers a callback to listen for script execution output.

Parameters ​

Parameter NameTypeRequired/DefaultDescription
callbackfunctionRequiredCallback function, receives the script output object

Return Value ​

None

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

void OnScriptOutput(object outputData)
{
    try
    {
        Debug.Log($"[ScriptOutputCallback] Received script output: {outputData}");
        
        // Attempt to parse script output data
        string outputText = "【Script Output】\n";
        
        if (outputData == null)
        {
            outputText += "Output data is null";
        }
        else
        {
            // Parse output data using reflection or type conversion
            var dataType = outputData.GetType();
            outputText += $"Data Type: {dataType.Name}\n";
            outputText += $"Details: {outputData}\n";
            
            // Attempt to get common fields
            try
            {
                var taskIdProp = dataType.GetProperty("task_id") ?? dataType.GetProperty("taskId");
                var outputProp = dataType.GetProperty("output") ?? dataType.GetProperty("content");
                var timestampProp = dataType.GetProperty("timestamp");
                
                if (taskIdProp != null)
                {
                    var taskId = taskIdProp.GetValue(outputData);
                    outputText += $"Task ID: {taskId}\n";
                }
                
                if (timestampProp != null)
                {
                    var timestamp = timestampProp.GetValue(outputData);
                    outputText += $"Timestamp: {timestamp}\n";
                }
                
                if (outputProp != null)
                {
                    var output = outputProp.GetValue(outputData);
                    outputText += $"Output Content:\n{output}\n";
                }
            }
            catch (Exception parseEx)
            {
                Debug.LogWarning($"Failed to parse script output fields: {parseEx.Message}");
            }
        }
    }
    catch (Exception ex)
    {
        Debug.LogError($"Error in OnScriptOutput: {ex.Message}\n{ex.StackTrace}");
    }
}

bool success = _robotTaskClient.RegisterScriptOutputCallback(OnScriptOutput);
if (success)
{
    Debug.Log("✓ Script output callback registered successfully");
}
else
{
    Debug.LogError("✗ Failed to register script output callback");
}
csharp
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setScriptOutputCallback([](const Lenovo::Daystar::ScriptOutput &output) {
    std::cout << "[Callback] Script output: Level=" << output.level 
        << ", Content=" << output.output << std::endl;
});
std::cout << "✓ Script output callback registered successfully" << std::endl;

UnregisterTaskStatusCallback ​

Function Prototypes ​

  • C#: bool UnregisterTaskStatusCallback()
  • C++: void setTaskStatusCallback(nullptr)
  • Python: async def unregister_task_status() -> bool
  • Java: void UnregisterTaskStatusFeedback()

Function Description ​

Unregisters the task status callback.

Parameters ​

None

Return Value ​

  • C#: bool (Success)
  • Python: bool (Success)
  • C++/Java: void

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

bool success = _robotTaskClient.UnregisterTaskStatusCallback();
if (success)
{
    Debug.Log("✓ Task status callback unregistered successfully");
}
else
{
    Debug.LogError("✗ Failed to unregister task status callback");
}
python
# Python
from daystar_sdk import WebSocketRobotClient

with WebSocketRobotClient(host='localhost', port=5252) as client:
    await client.unregister_task_status()
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.UnregisterTaskStatusFeedback();
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setTaskStatusCallback(nullptr);
std::cout << "✓ Task status callback unregistered successfully" << std::endl;

UnregisterScriptOutputCallback ​

Function Prototypes ​

  • C#: bool UnregisterScriptOutputCallback()
  • C++: void setScriptOutputCallback(nullptr)
  • Java: void unregisterScriptOutputFeedback()
  • Python: N/A

Function Description ​

Unregisters the script output callback.

Parameters ​

None

Return Value ​

  • C#: bool (Success)
  • C++/Java: void

Code Example ​

csharp
// C#
private RobotSDKManager _robotSDKManager;
private RobotTaskClient _robotTaskClient;

_robotSDKManager = RobotSDKManager.Instance;
_robotTaskClient = _robotSDKManager.CreateRobotTaskClient();

bool success = _robotTaskClient.UnregisterScriptOutputCallback();
if (success)
{
    Debug.Log("✓ Script output callback unregistered successfully");
}
else
{
    Debug.LogError("✗ Failed to unregister script output callback");
}
java
// Java
import com.lenovo.daystar_bot_sdk_client.client.SlamNaviClient;
import com.lenovo.daystar_bot_sdk_client.RobotSDKManager;
import com.lenovo.daystar_bot_sdk_client.DataEntities.RobotType;
import com.lenovo.daystar_bot_sdk_client.adapter.IRobotAdapter;

RobotSDKManager sdkManager = RobotSDKManager.getInstance();
IRobotAdapter adapter = sdkManager.createRobotAdapter(RobotType.HEXAPOD);
TaskServiceClient task = new TaskServiceClient(adapter);
task.unregisterScriptOutputFeedback();
cpp
// C++
Lenovo::Daystar::SDK sdk;

if (!sdk.isConnected()) {
    std::cerr << "Can not connect SDK server with default settings"
              << std::endl;
    return 1;
} else {
    std::cout << "Connected with default settings" << std::endl;
}
auto &sysb = sdk.getSYSB();
sysb.setScriptOutputCallback(nullptr); 
std::cout << "✓ Script output callback unregistered successfully" << std::endl;

Copyright © 2019-2026 Daystar