Skip to main content

Bumi Comprehensive Usage Document

I、About the Bumi​

(I)Component Information​

info

The Bumi robot has 21 degrees of freedom (DoF) in total. Each arm has 4 DoF, including (left-handed coordinate system):

  1. Shoulder joint pitch
  2. Shoulder joint roll
  3. Upper arm joint yaw
  4. Elbow joint pitch

Each leg has 6 DoF, including:

  1. Hip joint pitch
  2. Hip joint roll
  3. Thigh joint yaw
  4. Knee joint pitch
  5. Ankle joint pitch
  6. Ankle joint roll

The waist has 1 DoF, including:

  1. Waist joint yaw

Equipped with multiple joint motor degrees of freedom, the Bumi robot is capable of achieving precise motion control and attitude control.

Details are as follows:

ParametersBumiBumi - Education Edition
Height, Width and Thickness (Standing)98cm*35cm*20cm
Weight with batteryApproximately 17kg
Total DoF21
DoF per leg6
DoF per arm4
Waist DoF1
Computing module/NVIDIA Jetson Orin (Nano Super / NX)
*Computing module not available for certain models
Joint communicationEthercat & Canfd
Maximum joint torque70N.m
Lower-leg & thigh lengthApproximately 513mm
Arm spanApproximately 312mm
Power supplyLithium Battery
Base computing power6 Tops6 + 67 / 117 Tops
Camera modelDC_V93Realsense D435ICB(EDU_Air except)
Perception sensorsIMU、cameras
Microphone arraystandard configuration
Speakerstandard configuration
Smart batteryQuick-release battery
Image transmissionAvailable within the app

hardware can be directly accessed on the computing board during development

ChargerYes
Mobile appYes
OTA upgradeYes
Battery life2~3H
Secondary development (HighController)Yes
Secondary development (LowController)/Yes
Component overview diagram

(II)Exterior Component Dimensions​

(III) Electrical Interface​

The following electrical interfaces are provided on the back of Bumi:

Serial No.TypeDescriptionQuantity
1RJ45Switch 1000 BASE-T1
2USBMotion Control Board / Computing Board USB 3.02
3HDMIMotion Control Board / Computing Board HD Display Cable1
tip

For Bumi models with a computing board, the rear interfaces belong to the computing board. For models without a computing board, the rear interfaces belong to the motion control board.

(IV) Airborne Computer​

TypeModel numberUserPasswordIPcomputing powerFrequencyMemory
Motion Control BoardRockchip RK3576The Motion Control Board is not open to usersThe Motion Control Board is not open to users192.168.55.1026 Tops2.4GHz8+64GB
Computing BoardNVIDIA Jetson orin nano supernoetixbumi192.168.55.10167 Tops1.7GHz8+128GB
Computing BoardNVIDIA Jetson orin NXnoetixbumi192.168.55.101117 Tops2.0GHz16+128GB
danger

The Motion Control Board (Rockchip RK3576) is not accessible to users. If the user accesses the Motion Control Board without authorization and this causes the robot’s motion control program to malfunction or lose control, our company shall not be responsible for any resulting damage or losses.

(V)Camera Information​

Bumi-EDU:Realsense D435i

Intel® RealSense™ Depth Camera D435i - Product Specifications | Intel

Bumi-Standard: DC_V93

(VI)Battery Information​

ParametersInformation
BrandShenzhen Grepow
Model numberGRP6752097-13S1P
Capacity5100mAh
Voltage48V
Weight1360g

(VII) Charger Specifications​

ParametersInformation
Product ModelTA300 Robot
Input100-240V~50/60Hz 4.5A
Battery TypeLiPo/LiFe/LiHV 13S-16S
Dimensions172*97*46mm
Product NameSmart charger
Output35-72V ⎓ 7.5A 350W Max
Working ModeCharge/charging
Weight510g±10g

II. Instructions for Use​

(I)Powering On and Precautions​

info

1. Removing and Placing the Device​

  1. Remove Bumi from its storage position.
  2. Steady the robot and place it in a seated position on the floor.

2. Installing the Battery​

  1. Insert the battery into the battery compartment on the back of Bumi.
  2. Confirm that the battery is fully seated and the latch is locked.

3. Powering On​

  1. Press the battery switch once briefly and confirm that the battery indicator lights up.
  2. Then press and hold the battery switch until the indicator shows a flowing-light effect.
  3. Wait for the robot to complete startup.

4. Initial Attitude Adjustment​

  1. Place Bumiflat on its back facing upward on the floor,Make sure the floor is level and non-slip, there are no foreign objects on Bumi's foot plates, and there are no obstacles around it, so that surrounding objects do not interfere with the automatic stand-up sequence.

5. System Initialization Instructions​

  1. After power-on, Bumi automatically enters full-body enabled mode::
    • All joints automatically move to the zero position
    • Do not interfere with or obstruct joint movement during this process

⚠️ CAUTION

  • During startup, avoid touching the joints to prevent pinching injuries or interference with initialization.
  • Ensure the ground is level to avoid abnormal attitude.
  • Do not power on the robot unless the battery is correctly installed.

(II) Bumi Connection Method​

danger

After connecting to Bumi, do not select "Forget Device" in the system settings, as this will clear the other Bluetooth records and prevent the device from reconnecting.If this happens by mistake,please contact customer service.

(III) Connecting and Controlling Bumi with the Mobile App​

Noetix Run App Download:

Android:

iOS:NOETIX Run App - App Store

Noetix Run App User Guide: Noetix Run App User Guide

(IV) Powering Off and Battery Charging​

info

I. Preparing the Device for Storage​

  1. Run the One-Tap Storageoperation in the App.
  2. After storage is complete, steady Bumi and place it in a seated positionon the floor.

II. Powering Off​

  1. Press and hold the battery switch until Bumi is completely powered off.

III. Removing the Battery​

  1. Press and hold the battery latch.
  2. Remove the batteryfrom the battery compartment on the back of Bumi.

IV. Charging the Battery​

  1. Place the battery on the battery base and make sure the connection is secure.
  2. Connect the charging adapter to the battery base.
  3. Plug the adapter into a 220 V power outlet.

V. Confirming Charging Status​

  1. Check the battery indicator:
  • ndicator flashing: charging
  • No indicator: battery fully charged

(V)Operation Tutorial Videos​

(I)App Download​

(II)Powering On​

(III)Activation and Binding​

danger

After connecting to Bumi, do not select 'Forget Device' in the system settings, as this will clear the Bluetooth records and prevent the device from reconnecting. If this happens by mistake, please contact customer service.

(IV)One-Tap Stand-Up​

danger

When using Bumi's One-Tap Stand-Up function, make sure the floor is level and non-slip, there are no foreign objects on Bumi’s foot plates, and there are no obstacles around it, so that surrounding objects do not interfere with the automatic stand-up sequence.

(V)Movement​

(VI)Basic Actions​

(VII)Teaching Mode​

(VIII)Dance Mode​

(IX)Action Library​

(X)Image Transmission Mode​

(XI)One-Tap Storage - Powering Off - Battery Charging​

danger

Before executing One-Tap Storage in the App, make sure the floor is level and non-slip and that there are no obstacles around the robot.

(XII) Voice Interaction​

(VI) Bumi Safety Manual​

danger

At present, humanoid robots are still in a stage of rapid development, and there is still room for improvement in both software and hardware technologies. To keep Bumi in good working condition and allow it to accompany you for a longer time, please read and follow this user guide carefully to avoid improper operation. Thank you for your understanding and support!

List of Hazardous Operations

  1. Do not use the Bumi robot in rainy weather

At present, to strike a balance between heat dissipation and protection, the Bumi robot does not feature an ultimate waterproof effect, and users should avoid operating it in humid, misty or rainy environments.

  1. Do not use Bumi on complex terrain for play

To balance material weight and motion-control performance, Bumi's motion-control performance has not reached an optimal level. Due to current industry limitations, most humanoid-robot motion-control algorithms are effectively “blind walking”: the built-in control algorithms cannot autonomously sense changes in terrain and adjust gait. Adaptability is low on uneven, soft, slippery surfaces, stairs, and slopes greater than 20 degrees, creating a risk of falls and damage. Do not use the robot in the above environments.

  1. Do not use Bumi's stand-up functions incorrectly

Bumi's One-Tap Stand-Up and Assisted Stand-Up functions both have explicit prerequisites.

Autonomous Stand-Up:

After Bumi powers on, it must be lying flat on the floor face-up, with all four limbs naturally positioned on both sides of the waist and both legs fully extended.

Do not power on with the robot's limb motors mechanically blocked at their limits. After startup, Bumi adjusts all motors to their initial positions. If a motor is already at a limit position, Bumi may be unable to reverse it, which may create a risk of motor burnout.

Assisted Stand-Up:

After Bumi powers on and enters enabled mode, the whole-body motors move to their initial positions. The user must assist Bumi into a standing posture and then use the Assisted Stand-Up function in the App.

Do not use Assisted Stand-Up when the robot is in any other posture, such as lying face-up or face-down. Otherwise, when Assisted Stand-Up is used, Bumi's motion-control program may interpret the IMU values as indicating that the robot has fallen and automatically enter protection mode.

  1. Do not use the stand-up function in an area with many surrounding obstacles

When using the stand-up function, note that the movement range is 3 m x 3 m. Do not place obstacles within this area. They may interfere with the motion-control program, causing stand-up failure or even a fall and damage.

  1. Do not use the stand-up function when Bumi's joint motors are placed at the wrong limit positions

When powering on Bumi, do not place the joint motors at their limit positions. Once Bumi's startup motion control program is fully launched, it will automatically adjust all the motors of the robot to their initial positions. If the joint motors are stuck due to an improper placement posture, there is a risk of motor burnout.

  1. Do not use the storage function in an area with many surrounding obstacles

Do not use the storage function where there are many surrounding obstacles, as this may affect the motion-control program and create a risk of loss of motion control, falling, and damage.

  1. Do not use the dance function in an area with many surrounding obstacles or pedestrians

Due to current industry limitations, most humanoid-robot motion-control algorithms are effectively “blind dancing.” In an area with many obstacles or pedestrians, there is a risk of falls, damage, or collisions with people.

  1. Do not intentionally switch Bumi between function modes rapidly and repeatedly

The motion-control program architecture has been highly optimized, so mode switching is very smooth and fast and can be performed between two modes without noticeable delay. However, physical inertia cannot be eliminated. Intentionally switching rapidly between two modes may generate excessive inertia and cause the robot to fall and be damaged.

  1. Do not intentionally interfere with Bumi while it is moving

Due to current industry limitations, most humanoid-robot motion-control algorithms are effectively “blind walking.” The motion-control program cannot truly sense the surrounding environment or actively resist disturbances to maintain stability, and Bumi is the same. Therefore, do not intentionally interfere with Bumi while it is moving, as this creates a risk of falling and damage.

  1. Do not lift the robot to keep its feet off the ground when Bumi is in a full-body walking gait.

When using the Bumi full-body walking gait, do not lift the robot to keep its feet suspended in the air. Since the current robot motion control program cannot accurately identify that the robot has been lifted off the ground under all circumstances, the robot may still continuously output joint torque according to the normal walking gait, which will cause abnormal stress on the joints and transmission components, and there are risks of motor damage as well as the robot falling and being damaged after landing back on the ground.

Video of Incorrect Operation​

III. Bumi Development Guide​

tip

Introduction to SDK

This document describes Bumi development based on the DDS messaging middleware. The SDK adopts a client/server (C/S) architecture: under an isolation mechanism, the DDS client program deployed on the robot's secondary-development computing board sends control commands at a rate of 500 Hz to the motion control program running on the motion control board, which acts as the server, and continuously retrieves the robot's current state.

(I) System Architecture Diagram​

(II) Developing Interfaces​

DDS C++ Python

(III) Obtaining the SDK​

https://github.com/Noetix-Robotics/noetix_sdk_bumi

(IV) URDF Files​

Bumi_URDF.zip

(V) Application Development - HighController​

tip

Introduction to Application Development

HighController is developed for upper-layer scheduling based on the OEM motion control strategy, which enables the rapid construction of robot automated applications without modifying the underlying control logic, supports integration with large language models, and facilitates the creation of customized intelligent behavior systems.

Typical applications include:

  • Combining visual algorithms with the OEM motion control system to realize autonomous perception and autonomous navigation
  • Integrating with the voice interaction module to realize natural language control
  • Integrating with large language models to dynamically generate and invoke original manufacturer's control actions based on inputs (this carries certain risks, requiring strict security policies)
  • Implementing a positioning and navigation inspection system in coordination with the External Perception Radar

Simply put, HighController encapsulates the original factory's control capabilities through high-level scheduling, enabling automated and programmatic invocation of the controllable behaviors of remote controllers or APPs, and on this basis, extends the system with selected autonomous and intelligent capabilities.

I、HighController Architecture Diagram​

(1) Status reporting mechanism

After the Client SDK establishes a connection with the robot motion control program, the motion control program will continuously send real-time robot status information to the Client, including:

  • Whole-body motor parameter data (pos (position), vel (velocity), tau (torque), kp, kd, temperature, error(error message))
  • IMU status data
  • Current working mode (workmode, indicating the currently running control strategy)
  • Aolion Controller Data (for Synchronized Manual Input or Auxiliary Control)
  • Battery level and related system status information

(2) Client control instruction delivery

The Client, based on its own application scenarios, sends control commands to the operation and control program, which mainly include:

  • (x, y, z) movement control data

is only valid in specific modes, such as walking mode, handshake, greeting, cheering, teaching mode, etc.

  • action command

corresponds to workmode, which is used to switch or trigger the algorithm strategy currently running on the robot.

  • data additional DDS data

PLAYTEACH (playback teaching mode), and is used to specify additional parameters such as the teaching file index.


(3) Internal processing flow of the operation control program

After receiving the client's instructions, the control program:

  • Transfers the control parameters to the internal control algorithm
  • The algorithm calculates the strategy based on the reinforcement learning model
  • Generate the target expected values (target position, velocity or torque) of the motor and send them to the motor control interface
  • Deliver the calculation results to the hardware control layer

(4) Hardware execution layer

After the hardware layer receives the target control data:

  • Execute motor control commands
  • Perform the corresponding expected action

Throughout the entire process, users only need to issue a portion of high-level control parameters.

The specific motion planning, dynamic balance and motor-level control calculations are all completed by the Black Box Algorithm in the original manufacturer's motion control program.

Therefore, in HighController mode, the range of capabilities that users can invoke and automate is, in principle, limited to the functional boundaries originally achievable by the APP or the controller, without granting underlying motor-level control access.

II、HighController Operation Flowchart​

(1) Initialization phase (init)

After the system is started, the following initialization process shall be completed:

  1. Establish a communication connection between the Client and the robot operation control program
  2. Register a callback function to receive robot status data

(2) The DDS callback thread continuously receives postback status

The operation control program continuously pushes robot status data to the Client.

After receiving the data, the callback function encapsulates it and stores it in the buffer and the global state variable respectively:

  • motor_state_buffer_:Motor status buffer
  • imu_buffer_:IMU status buffer
  • joy_buffer_:remote controller data buffer
  • curmode:Current operation control strategy mode
  • BmsState:Current battery information

III、Common Interfaces and Parameters of HighController​

HighController Interfaces
Interface NameInterface Descriptionreturn type
instanceObtain the singleton pointer of HighControllerObject pointer
initHighController Object InitializationNone
publish_cmdIssue DDS control command dataNone
subscribe_robot_hardware_statusSubscribe to robot hardware status informationNone

Obtain the singleton instance of the HighController object

Function Nameinstance
Function Prototypestatic HighController *Instance()
Function OverviewObtain the HighController singleton
ParametersNone
Return ValuePointer to the HighController singleton object
Note

C++ Example:

HighController *ctrl = HighController::Instance();

Python Example:

ctrl = HighController.instance()

HighController Object Initialization

Function Nameinit
Function Prototypebool init()
Function OverviewHighController Object Initialization
ParametersNone
Return Valuebool
Note

C++ Example:

ctrl->init();

Python Example:

ctrl.init()

Publish robot control commands

Function Nampublish_cmd
Function Prototypevoid publish_cmd(double x, double y, double z, ControlCmd action, uint16_t index)
Function OverviewUse HighController to send DDS control commands
Parameters
  • X range: [-1, 1]; robot longitudinal movement value (> 0 forward)
  • y range: [-1,1]; lateral movement value of the robot (>0 means moving left)
  • z range: [-1,1]; robot steering value (>0 means left turn)
  • action robot mode switching enumeration
  • index: specified index for teaching-related modes
Return ValueNone
NoteThis interface cannot be called continuously; otherwise, the robot will receive commands too fast to respond, and a delay of at least 2ms needs to be added after each command is sent.

C++ Example:

ctrl->publish_cmd(0, 0, 0, ControlCmd.CHEER, 0);

Python Example:

ctrl.publish_cmd(0, 0, 0, ControlCmd.CHEER, 0)

actionThe parameter indicates switching the robot to the corresponding mode

Parameter NameDefine PrototypeSerial No.Example ValueDescription
ControlCmd
enum class ControlCmd : uint8_t {
WALK,
SWING,
SHAKE,
CHEER,
RUN,
START,
SWITCH,
STARTTEACH,
SAVETEACH,
ENDTEACH,
PLAYTEACH,
DANCE,
FALLTOSTAND,
STANDTOFALL,
DANCE1,
DANCE2,
TEAR,
DEFAULT
};
0WALKWalking Mode
1SWINGFactory-Preset Action: Wave
2SHAKEFactory-Preset Action: Handshake
3CHEERFactory-Preset action: Cheer
4RUNReserved mode, not available in the current version
5STARTEnable/Disable
6SWITCHPreparation Mode
7STARTTEACHStart teaching
8SAVETEACHSave Teaching
9ENDTEACHEnd Teaching (Deprecated))
10PLAYTEACHPlay Demonstration
11DANCEDance 1 Mode
12FALLTOSTANDGet up from the ground
13STANDTOFALLGet up and fall to the ground
14DANCE1Dance 2 Mode
15DANCE2Dance 3 Mode
16TEARPreset Action: Wipe Tears
17DEFAULTNull Mode
tip

Purpose of the DEFAULT Empty Mode

And the process control function runs periodically. If teaching-related commands such as

action = ControlCmd::PLAYTEACH;

are continuously issued within this loop, the robot may repeatedly interrupt the teaching playback action before it has finished, causing the robot to appear stuck and unresponsive.

Correct Practice

PLAYTEACH is a one-time trigger instruction (event),and shall only be sent once;afterward, continuously send DEFAULT(a no-op command) in the loop to prevent repeated triggering.

Sample Code (Revised))

if (is_first) {
action = ControlCmd:: PLAYTEACH ; // Triggered only once`
is_first = false;
} else {
action = ControlCmd::DEFAULT;
}

Effect

  • Received PLAYTEACH → Trigger and fully execute the teaching action
  • Subsequent DEFAULT → No longer interrupts the action
  • The robot behaves normally and predictably

Action commands shall be "edge-triggered" and must not be continuously issued within a control loop.

tip

START Enable/Disable

workmode == 30,send START to put the robot into enabled mode

workmode != 30,send START to immediately put the robot into disabled mode

indexis used to specify the teaching file index in teaching-related modes

ctrl.publish_cmd(0, 0, ControlCmd.STARTTEACH, 0) # Begin teaching
sleep(10) # Record teaching actions
ctrl.publish_cmd(0, 0, ControlCmd.SAVETEACH, 1) # End and save the teaching action, specifying index 1.
sleep(2) # Allow the operation control program to complete the save process to prevent it from being interrupted by the next command.
ctrl.publish_cmd(0, 0, ControlCmd.PLAYTEACH, 1) # play teach file 1
tip

Only when action is one of the following modes: TEAR/PLAYTEACH/WALK/SWING/CHEER/SHAKE/DEFAULT

x and yaw will take effect to control the robot's movement; in other modes, x and yaw are invalid.

Subscribe to robot hardware status information

Function Namesubscribe_robot_hardware_status
Function Prototypevoid subscribe_robot_hardware_status(RobotHardwareStatusCallback callback);
Function OverviewSubscribe to robot hardware status information
Parameters- callback: callback function for processing robot status data
Return ValueNone
Note

C++ Example:

ctrl->subscribe_robot_hardware_status(
[](const RobotHardwareStatus &status) {
latest_hw_status = status;
});

Python Example:

def _on_hw_status(status):
global latest_hw_status
latest_hw_status = status

ctrl.subscribe_robot_hardware_status(_on_hw_status)
Parameter NameDefine PrototypeParametersDescription
RobotHardwareStatus
struct RobotHardwareStatus {
NingImuData imu_data;
joydata remote_data;
std::array<MotorState, 21> motor_data;
RobotBmsData bms_data;
int workmode;
};
imu_dataIMU data
remote_dataController Data
motor_dataMotor Data
bms_dataBattery Data
workmodeCurrent operating mode

workmode parameter correspondence table

The workmode value is only valid in highcontroller mode

int值Description
0Enable Mode
1Preparation Mode
2Walking Mode
5Dance Mode
8Factory Preset Action: Greeting
9Factory Default Action: Handshake
10Factory Default Action: Cheer
11Start teaching
12End Teaching
14Save Teaching 1
23Play Demonstration
26Protected Mode
27Get up from the ground
28Get up and fall to the ground
29Save Teaching 2
30Disabled Mode
31Dance Mode 1
32Dance Mode 2
33tear-wiping gesture
caution

Save Teaching Mode
After the SDK sends a SAVETEACH command to the robot, the robot will sequentially return three statuses: Exit Teaching Save Teaching 1 Save Teaching 2

caution

Protected Mode

Under the standing control strategy (walking, teaching, dancing, etc.), the motion control program continuously monitors the IMU attitude data.

When the system detects that the posture deviates from the standing stability range and exceeds the preset threshold, it will immediately trigger the protection mechanism and forcibly switch to the safe mode.

In protected mode:

  • All joints of the body enter a disabled state (the motor stops active output)
  • Terminate the current motion control strategy
  • Block the execution of further action instructions

The purpose of this mechanism is as follows:

  • Prevent the robot from continuously outputting control torque during a fall or instability
  • Avoid secondary injury caused by uncontrolled swinging of the limbs
  • Mitigate potential damage to the equipment itself and the surrounding environment

This protection logic, as a underlying safety protection mechanism, enjoys the highest priority and will not be affected by upper-layer control instructions.

Handle Data Structure

Parameter NameDefine PrototypeExample ValueDescription
joydata
struct joydata {
double axes[2];
int button[14];
};
axesRemote control remote sensing linear value
buttonRemote control button press mapping value: 1 means pressed, 0 means normal
Handle Joystick MappingMapping DescriptionScope
axes[0]Right Stick Left-Right Push Value[-1, 1]
axes[1]Left Stick Forward/Backward Push Value[-1, 1]
tip

The Bumi backplane with a computing board features an interface for the computing board, and the motion control board cannot accommodate the controller receiver, so the DDS cannot obtain controller data. Therefore, the controller data needs to be acquired directly from the computing board. For details, please refer to Direct Acquisition of Controller Data via computing Board

IMU State Data Structure

Parameter NameDefine PrototypeExample ValueDescription
NingImuData
struct NingImuData {
double ori[4];
double ori_cov[9];
double angular_vel[3];
double angular_vel_cov[9];
double linear_acc[3];
double linear_acc_cov[9];
};
oriAttitude Quaternion
ori_covattitude covariance
angular_velangular velocity
angular_vel_covangular velocity covariance
linear_acclinear acceleration
linear_acc_covLinear acceleration covariance

Motor status data structure

Parameter NameDefine PrototypeExample ValueDescriptionDescription
MotorState
struct MotorState {
double pos;
double vel;
double tau;
uint16_t motor_id;
uint8_t error;
int temperature;
};
posMotor Position
velMotor speed
tauMotor Torque
motor_idMotor ID
error

Motor Error Code:
02H: Motor overcurrent
03H: Motor voltage is too low
04H: Motor encoder error
06H: Motor brake voltage is too high
07H: DRV driver error
08H: Overpressure
09H: Under-voltage
0AH: Overcurrent
0BH: MOS Over-Temperature
0CH: Motor coil over-temperature
0DH: Communication loss
0EH: Overload

temperatureTemperature

Battery Status Data Structure

Parameter NameDefine PrototypeExample ValueDescription
RobotBmsData
struct RobotBmsData {
uint16_t battery_temp_ = 0;
uint16_t battery_alarm_ = 0;
uint16_t battery_soc_ = 0;
uint16_t battery_soh_ = 0;
};
battery_temp_Temperature
battery_alarm_Alarm Information
battery_soc_Electric quantity
battery_soh_Health Level

IV、Operation Control Status Switching Flowchart​

danger

Note: During the development process with HighController, please follow the above flow chart for mode switching to ensure rationality and safety.

V、Introduction to Demo Routines​

In the SDK folder, examples/cpp/example_high.cpp 与 examples/py/test_high.py provide a sample demo, which is used to parse the input data of the Aolion Controller, and generate corresponding control instructions according to the controller operations to send to the robot.

(VI)Operation Control Development - LowController​

tip

Introduction to Operations Control Development

LowController exposes the motor control interface in the motion control program to the SDK, allowing users to directly adjust underlying motor parameters at a control frequency of 500Hz. Combined with the deployment of reinforcement learning algorithms, it enables in-depth customization of Bumi's motion capabilities, allowing it to complete complex behaviors such as diverse new movements and dances.

caution

Note: Only the EDU version of Bumi supports LowController development

(I)Bumi Training Framework​

https://github.com/Noetix-Robotics/noetix_bumi_lab

(II)LowController Architecture Diagram​

(1) Status Data Reporting

After the client SDK establishes a connection with the robot motion control program, the motion control program continuously pushes real-time robot status information to the client, including:

  • Whole-body motor parameter data(pos position, vel velocity, tau torque, kp, kd, temperature, error)
  • IMU status data.
  • Aolion controller data (for synchronizing manual input or auxiliary control).

(2) Client-side control calculation

The Client, in combination with its own algorithm (usually a reinforcement learning model), performs real-time policy calculation to generate the target expected values (such as target position, etc.) for each motor, writes the motor control instruction array into the buffer, and then delivers it to the motion control program.


(3) Forwarding Mechanism of Operation Control Program

After the operation control program receives the motor command array issued by the Client, it does not perform high-level strategy calculation, but directly forwards the control parameters to the hardware control layer.


(4) Hardware Execution Layer

The hardware layer receives the target parameters of the motor, executes the control commands, and drives the motor to complete the expected actions.


In LowController mode:

  • The reinforcement learning model is deployed on the Client side
  • Users can directly participate in motor-level control
  • The operation control program is mainly responsible for communication and secure forwarding.
  • The control frequency can reach 500Hz

This mode features higher control freedom and flexibility, but it also means:

  • Higher requirements for algorithm stability.
  • Stricter requirements for real-time performance and system security.
  • A potential direct impact on robot motion safety if the control strategy is unstable.

(III)LowController Operation Flowchart​

(1) Initialization phase (init)

After the system starts, complete the following initialization steps:

  1. Establish a communication connection between the Client and the robot operation control program
  2. Register robot status data receiving callback function
  3. Create send_thread data transmission thread

(2) Status Data Callback Mechanism

The operation control program continuously pushes robot status data to the Client.

After receiving the data, the callback function encapsulates it and stores it in the corresponding buffer or global variable:

  • motor_state_buffer_: Motor status buffer
  • imu_buffer_: IMU status buffer
  • joy_buffer_: controller data buffer

This stage is only responsible for data reception and caching, and does not participate in control strategy calculation.


(3)send_thread(data transmission thread)

The data transmission thread also operates at a 2 ms cycle:

  • If motor_cmd_buffer_ is not empty
  • Read the latest motor control command
  • Send the motor target array to the motion control program

The operation control program is only responsible for forwarding data to the hardware layer and does not participate in high-level control decisions.


(4) Architectural Features

The core features of the LowController mode are as follows:

  • Client directly participates in motor-level control
  • Reinforcement learning or custom control algorithms run on the Client
  • The operation control program is no longer responsible for high-level policy calculation, and only undertakes the responsibilities of communication and secure forwarding.
  • The control frequency can reach up to 500Hz

This model offers higher control freedom and algorithmic plasticity, but at the same time, it imposes requirements on:

  • Real-time performance
  • Algorithm Stability
  • Thread Safety and Scheduling Precision

set higher requirements.

4. Joint Motor Information​

IDNameJointTorqueAngle RangeRadian Range
0arm_l1_jointLeft shoulder joint pitch5 N.m-135135-2.362.36
1arm_l2_jointLeft shoulder joint roll5 N.m-8111-0.141.94
2arm_l3_jointLeft arm joint yaw5 N.m-9090-1.571.57
3arm_l4_jointLeft elbow pitch5 N.m-1290-2.260.00
4leg_l1_jointLeft hip pitch60 N.m-120120-2.092.09
5leg_l2_jointLeft hip roll60 N.m-3890-0.661.57
6leg_l3_jointLeft thigh joint yaw15 N.m-145145-2.532.53
7leg_l4_jointLeft knee joint pitch60 N.m01280.002.24
8leg_l5_jointLeft ankle pitch30 N.m-5525-0.960.44
9leg_l6_jointLeft ankle roll30 N.m-1010-0.170.17
10arm_r1_jointRight shoulder pitch5 N.m-135135-2.362.36
11arm_r2_jointRight shoulder joint roll5 N.m-1118-1.940.14
12arm_r3_jointRight arm joint yaw5 N.m-9090-1.571.57
13arm_r4_jointRight elbow joint pitch5 N.m-1290-2.260.00
14leg_r1_jointRight hip pitch60 N.m-120120-2.092.09
15leg_r2_jointRight hip joint roll60 N.m-9038-1.570.66
16leg_r3_jointRight thigh joint yaw15 N.m-145145-2.532.53
17leg_r4_jointRight knee joint pitch60 N.m01280.002.24
18leg_r5_jointRight ankle pitch30 N.m-5525-0.960.44
19leg_r6_jointRight ankle joint roll30 N.m-1010-0.170.17
20waist_1_jointWaist joint yaw27 N.m-9090-1.571.57

MotorCmd. pos corresponds to the radian information

(V)Aolion Controller Data Mapping​

Aolion Controller. The button[] and key mapping table are as follows:

Key DescriptionButton index
Right Shoulder Button1
Left Shoulder Button2
X5
Y6
B7
A8
+9
-10
None11
Press the left joystick12
Handle Joystick MappingMapping Description
axes[0]Right Stick Y-Axis Value
axes[1]Left Stick X-axis Value

Joystick Data Range

Minimum ValueMaximum Value
-11

(VI)Common Interfaces and Usage Routines of LowController​

LowController Interface
Interface NameInterface Descriptionreturn type
instanceObtain the singleton pointer of LowControllerObject pointer
initLowController Object InitializationNone
set_jointWrite the motor control command into the bufferNone
getJointsIndexObtain the corresponding ID based on the joint nameint
subscribe_robot_hardware_statusSubscribe to robot hardware status informationNone

Obtain the singleton instance of the LowController object

Function Nameinstance
Function Prototypestatic LowController *Instance()
Function OverviewObtain the LowController singleton
ParametersNone
Return ValuePointer to the LowController singleton object
Note

C++ Example:

LowController *ctrl = LowController::Instance();

Python Example:

ctrl = LowController.instance()

LowController Object Initialization

Function Nameinit
Function Prototypebool init()
Function OverviewLowController Object Initialization
ParametersNone
Return Valuebool
Note

C++ Example:

ctrl->init();

Python Example:

ctrl.init()

The motor control command array is stored in the buffer

After being stored in the buffer, the data will be automatically sent by the send_thread thread.

Function Nameset_joint
Function Prototypevoid set_joint(std::array<MotorCmd, 21> motorcmd)
Function OverviewSet joint data
Parameters- motorcmd motor command structure
Return ValueNone
Note
Parameter NameDefine PrototypeExample ValueDescription
MotorCmd
struct MotorCmd {
double pos;
double vel;
double tau;
double kp;
double kd;
uint16_t motor_id;
};
posMotor Position
velMotor speed
tauMotor Torque
kppid parameter
kdpid parameter
motor_idMotor ID
danger

When issuing motor control commands, please strictly refer to the specified parameter ranges in.

C++ Example:

std::array<MotorCmd, 21> motorcmd;
// Algorithm logic omitted...
ctrl->set_joint(motorcmd);

Python Example:

cmds = [MotorCmd() for _ in range(21)]
# Algorithm logic omitted...
ctrl.set_joint(cmds)

Obtain the corresponding joint motor ID according to the joint motor name

Function NamegetJointsIndex
Function Prototypeint getJointsIndex(std::string jointname)
Function OverviewObtain the corresponding joint motor ID according to the joint motor name
Parametersjointname: Joint Motor Name
Return Valueint:Corresponding joint motor ID
Note

C++ Example:

int id = ctrl->getJointsIndex("arm_l1_joint");

Python Example:

id = ctrl.getJointsIndex("arm_l1_joint")

Subscribe to robot hardware status information

Function Namesubscribe_robot_hardware_status
Function Prototypevoid subscribe_robot_hardware_status(RobotHardwareStatusCallback callback);
Function OverviewSubscribe to robot hardware status information
Parameters- callback:callback function for processing robot status data
Return ValueNone
NoteThe usage is the same as that of HighController subscribe_robot_hardware_status
Obtain the data of the Aolion controller (for Bumi models equipped with a computing board, the data can be directly obtained via the computing board)​

AoLionDriver class

AoLionDriver Class Interface
initInitialize
getremotedataObtain controller data
Function Nameinit
Function Prototypebool init(std::string port, int baudrate)
Function OverviewInitialize the handle device port
Parameters
  • port: device Port Number, defaulting to /dev/input/js0
  • baudrate: baud rate, default value is 115200
Return Value

true:Initialization succeeded


falese: Initialization failed

Note
Function Namegetremotedata
Function Prototypeconst joydata getremotedata()
Function OverviewObtain controller data
ParametersNone
Return Valuejoydata:Handle data structure
Note

Usage Example

C++

AoLionDriver aoliondriver;
joydata remote_data;
aoliondriver.init("/dev/input/js0", 115200);
const joydata jdata=aoliondriver.getremotedata();
for (int i = 0; i < 14; i++)
std::cout << jdata.button[i] << std::endl;
std::cout << jdata.axes[0] << std::endl;
std::cout << jdata.axes[1] << std::endl;

Python

al = AoLionDriver()
al.init("/dev/input/js0", 115200)
jdata = al.getremotedata()
for i in range(14):
print(jdata.button[i])
print(jdata.axes[0])
print(jdata.axes[1])

(VII)Introduction to Demo Routines​

examples/cpp/example_policy_walk.cpp and examples/py/test_policy.py run a Bumi 21 degrees of freedom running strategy(policy/policy.onnx)of the sim2real (algorithm model real machine deployment) code, according to the policy provides some reinforcement learning deployment interface

Function NameloadModel
Function Prototypebool loadModel(std::string modelpath)
Function OverviewLoad custom models
Parameters
  • modelpath: model path
Return Valuetrue: Load succeeded; false: Load failed
Note
Function Nameonnxdatainit
Function Prototypevoid onnxdatainit()
Function OverviewInitialize onnx data
ParametersNone
Return ValueNone
Note
Function Namegetmodelparam
Function Prototypebool getmodelparam()
Function OverviewObtain model parameters from the yaml file
ParametersNone
Return Valuetrue: YAML file read successfully; false: Failed to read YAML file
Note
Function Namesetparameter
Function Prototypevoid setparameter(Command &cmd,bool* isfirst)
Function OverviewSet the overall control parameters of the xyz unit
Parameters
  • cmd:set command
  • isfirst: Indicates whether this is the first configuration
Return ValueNone
Note
Function Nameupdatestateestimation
Function Prototypebool updatestateestimation()
Function OverviewUpdate the status, including joint angles, IMU data, etc. , and obtain model parameters from the yaml file
ParametersNone
Return Valuetrue: YAML file read successfully; false: Failed to read YAML file
Note
Function NamecomputeObservation
Function Prototypevoid computeObservation()
Function OverviewCalculate the observation coefficients
ParametersNone
Return ValueNone
Note
Function NamecomputeActions
Function Prototypevoid computeActions()
Function OverviewCalculate the final action
ParametersNone
Return ValueNone
Note

Joystick Operation Procedure

Usage Instructions
+All joints return to zero position and enter damping mode
LB & -Keep your limbs slightly bent, and get into the pre-strategy preparation mode
LB & XEnter the policy-controlled running mode

(VII) Audio and video Development​

tip

Introduction to Audio Development

MediaController establishes a communication link with the voice module on the motion control board via DDS topics, enabling control of Bumi audio peripherals (such as speakers and microphones) and providing capabilities for voice interaction agent configuration and data stream management.

caution

Note Only the EDU version of Bumi supports MediaController development
The open-source interfaces are as follows:

Status control and acquisition interface: supports functions including wakeup control, sleep control, module restart, operating status acquisition, and error information acquisition;

General configuration interface: an interface for configuring and retrieving general parameters, including non-dialogue sleep timeout duration, wake-up word, wake-up reply word, sleep reply word, as well as audio-visual data stream control;

Audio Interface: Audio stream push and retrieval, audio control commands (pause/resume, volume adjustment, etc.)

Video interface, video stream push and acquisition, video control instructions (pause and resume, etc.)

(I)MediaController Architecture Diagram​

(1) Media service status and data reporting

After the Client SDK establishes a connection with the robot media service program, the media service program will continuously push real-time robot media status information to the Client, including:

  1. Continuous acquisition of internal audio and video data streams (only Bumi models without computing board can acquire internal video streams)
  2. Partial agent configuration reporting (actively obtained for the first time, and reported after subsequent changes)
  3. Acquisition of desensitized processed video stream (the version equipped with a computing board needs to continuously output external video streams to the audio-visual interaction system)

(2) Delivery of media data streams and configuration data

  1. Publish external audio stream data to the agent as input, or send it to the internal speaker for output
  2. Publish external video stream data for agent recognition
  3. Modify some Agent configuration settings, including volume, timeout, wake word, wake-up response, sleep response, and the data stream routing switch.

Currently, the input and output data collected for information acquisition only support the following specifications: channels= 8, sample_rate= 16000, format= 2 (16-bit little-endian)

采集信息输入输出数据.png

Currently, the playback information input and output data only supports the following specifications: channels= 2, sample_rate= 16000, format= 2 (16-bit little-endian)

播放信息输入输出数据.png

The captured data and playback data are interleaved.

(II)MediaController Startup Flowchart​

MediaController启动流程图.png

III)Common Parameters of MediaController​

DDS Packet Header Structure

Parameter NameDefine PrototypeMemberDescription
Header
struct Header {
uint64_t message_id = 0;
uint64_t timestamp_us = 0;
std::string sn;
};
message_idDDS Message ID
timestamp_usus timestamp
snThe current SN number of the Bumi device

System Status Control

SystemControlType
enumerationDescription
TO_WAKEUPWake up the audio and video interaction system agent
TO_SLEEPDormant audio-video interaction system agent
TO_RESETRestart the audio and video interaction system agent

System Status

Parameter NameDefine PrototypeMemberDescription
SystemStatus
struct SystemStatus {
Header header;
WorkStatus value = WorkStatus::READY;
StatusChangeReason reason = StatusChangeReason::SYSTEM_LAUNCH;
};
headerDDS Header
valueagent status
reasonStatus Reason
WorkStatus
enumerationDescription
READYReady State
SLEEPEDSleep state
WAKEUPEDAwake State
EXITExit Status
StatusChangeReason
EnumerationDescription
SYSTEM_LAUNCHSystem Startup
CMD_RESETCommand Reboot
AUDIO_WAKEUPEDVoice Wake-up
CMD_WAKEUPEDInstruction Wake-up
AUDIO_SLEEPEDVoice Sleep
CMD_SLEEPEDInstruction Sleep
TIMEOUT_SLEEPEDTimeout Hibernation
ERROR_SLEEPEDFalse Hibernation

Voice wake-up refers to triggering through actual human-computer voice interaction; command wake-up refers to triggering through DDS or other forms of commands;

System Error

Parameter NameDefine PrototypeMemberDescription
SystemError
struct SystemError {
Header header;
int32_t code = 0;
std::string message;
};
headerDDS Header
codeError Code
messageError Message

Audio stream data

Parameter NameDefine PrototypeMemberDescription
AudioStream
struct AudioStream {
Header header;
uint64_t timestamp_us = 0;
uint32_t channels = 0;
uint32_t sample_rate = 0;
uint32_t format = 0;
uint32_t duration_ms = 0;
std::vector<int16_t> audio_data;
};
headerDDS Header
timestamp_usTimestamp (us)
channelsNumber of channels
sample_ratesampling rate
formatData Format
duration_msTime (ms))
audio_dataaudio data

video stream data

Parameter NameDefine PrototypeExample ValueDescription
VideoStream
struct VideoStream {
Header header;
uint64_t timestamp_us = 0;
uint32_t format = 0;
uint32_t width = 0;
uint32_t height = 0;
uint32_t fps = 0;
std::vector<uint8_t> video_data;
};
headerDDS Header
timestamp_usTimestamp (us)
formatFormat: 1: YUYV Currently only the YUYV format is supported
widthHorizontal Pixels per Frame
heightVertical pixels per frame
fpsframe rate
video_dataframe image data

(IV)Common Interfaces of MediaController​

MediaController Interface
Interface NameInterface Descriptionreturn type
InstanceObtain the singleton pointer of MediaControllerObject pointer
initMediaController Object Initializationbool
set_system_controlSet the control status of the voice interaction systemNone
subscribe_system_statusSubscribe to status information of the audio-visual interactive systemNone
subscribe_system_errorSubscribe to error status information of audio-visual interaction systemNone
get_volumeGet the current volume of the audio-visual interaction system Range: 0–200int
set_volumeSet the volume of the current audio-visual interaction system Range: 0–200None
get_timeoutGet the inactivity timeout before entering sleep modeint
set_timeoutSet the inactivity timeout before entering sleep modeNone
get_audio_cue_enableget the enabled status of the prompt tone of the audio-visual interaction systembool
set_audio_cue_enableSet whether the prompt sound of the audio-visual interaction system is enabledNone
get_internal_capture_audio_data_to_agent_enableGet the internal microphone audio input status for the Agentbool
set_internal_capture_audio_data_to_agent_enableSet the internal microphone audio input status for the AgentNone
get_external_custom_audio_data_to_agent_enableGet the enabled status of external audio stream input for the agentbool
set_external_custom_audio_data_to_agent_enableSet the enabled status of external audio stream input for the agentNone
get_internal_agent_audio_data_to_playback_enableGet the enabled status of agent audio stream output to the internal speaker.bool
set_internal_agent_audio_data_to_playback_enableSet the enabled status of agent audio stream output to the internal speaker.None
get_external_custom_audio_data_to_playback_enableGet the enabled status of external audio stream output to the internal speaker.bool
set_external_custom_audio_data_to_playback_enableGet the enabled status of external audio stream output to the internal speaker.None
get_internal_capture_video_data_to_agent_enableGet the enabled status of internal video stream input to the agent.bool
set_internal_capture_video_data_to_agent_enableSet the enabled status of internal video stream input to the agent.None
get_external_custom_video_data_to_agent_enableGet the enabled status of external video stream input to the agent.bool
set_external_custom_video_data_to_agent_enableSet the enabled status of external video stream input to the agent.None
get_external_custom_audio_data_to_agent_use_internal_3aGet the enabled status of using the internal 3A algorithm for external audio stream input to the agent.bool
set_external_custom_audio_data_to_agent_use_internal_3aSet the enabled status of using the internal 3A algorithm for external audio stream input to the agent.None
get_wakeup_response_wordsGet wake-up response wordsstring
set_wakeup_response_wordsSet wake-up response wordsNone
get_sleep_response_wordsGet dormant response wordsstring
set_sleep_response_wordsSet sleep response wordsNone
get_wakeup_wordsGet all wake wordsstring
add_wakeup_wordsAdd wake-up wordsbool
reset_wakeup_wordsReset factory default wake-up wordNone
subscribe_internal_audio_captureSubscribe to the audio stream captured by the internal microphoneNone
subscribe_internal_audio_playbackSubscribe to the audio stream played by the robot's internal speakerNone
subscribe_internal_video_capture
Subscribe to the video stream collected by the camera inside the robot (only available for Bumi without computing power board)VideoStream struct
subscribe_internal_video_desensedSubscribe to the audio-visual interaction system. The processed desensitized video stream (the Bumi equipped with a computing power board needs to continuously publish the availability of the external video stream)VideoStream struct
pause_video_capturePause the internal camera Data Acquisition of the robot (only available for Bumi without computing power board)None
resume_video_captureResume the internal camera Data Acquisition of the robot (only available for Bumi without computing power board)None
publish_external_video_streamPublish external video streams to the audio-visual interaction systemNone
publish_external_audio_streamPublish external audio stream input to the agentNone
publish_external_audio_playback_streamPublish external audio stream output to the internal speakerNone
pause_audio_capturePause internal microphone audio stream captureNone
resume_audio_captureResume internal microphone audio stream captureNone
pause_audio_playbackPause the audio stream output of the internal speakerNone
resume_audio_playbackResume the audio stream output of the internal speakerNone
danger

All Set Agent configuration APIs (e.g., changing the volume, changing data switches, etc.) must not be called more frequently than once every 500 ms; otherwise, the voice interaction system may crash. If this issue occurs, please contact Noetix After-sales Service.

Get the singleton of the MediaController object

Function Nameinstance
Function Prototypestatic MediaController *Instance()
Function OverviewGet the MediaController singleton
ParametersNone
Return ValueSingleton pointer to the MediaController object
Note

C++ Example:

MediaController *ctrl = MediaController::Instance();

Python Example:

ctrl = MediaController.instance()

MediaController Object Initialization

Function Nameinit
Function Prototypebool init()
Function OverviewMediaController Object Initialization
ParametersNone
Return Valuebool
Note

C++ Example::

ctrl->init();

Python Example:

ctrl.init()

Set the status of the audio-visual interaction system

Function Nameset_system_control
Function Prototypevoid set_system_control(media::SystemControlType type, bool is_need_reply);
Function OverviewSet the status of the audio-video interaction system (wake-up, sleep, restart)
Parameters
- type:System Status
- is_need_reply:whether to trigger the wake-up/sleep reply words
Return ValueNone
Note

C++ Example:

ctrl->set_system_control(media::SystemControlType::TO_WAKEUP, true);

Python Example:

ctrl.set_system_control(media::SystemControlType::TO_WAKEUP, true)

Subscribe to the status information of the audio-visual interaction system

Function Namesubscribe_system_status
Function Prototypevoid subscribe_system_status(SystemstatusCallback callback);
Function OverviewSubscribe to status information of the audio-visual interactive system
Parameters- callback:The callback function that needs to be triggered when the state changes
Return ValueNone
Note

C++ Example:

ctrl->subscribe_system_status([&](const media::SystemStatus &status){
printf("status is %d \r\n" , static_cast<int>(status.value));
});

Python Example:

def on_status_switch(status):
print(status.value)

ctrl.subscribe_system_status(on_status_switch)

Subscribe to system error messages of the audio-visual interaction system

Function Namesubscribe_system_error
Function Prototypevoid subscribe_system_error(SystemerrorCallback callback);
Function OverviewSubscribe to system error messages of the audio-visual interaction system
Parameters- callback: the callback triggered by a DDS message containing error information
Return ValueNone
Note

C++ Example:

ctrl->subscribe_system_error([&](const media::SystemError &error){
printf("status is %s \r\n", error.message.c_str());
});

Python Example:

def on_error(error):
print(error.message)

ctrl.subscribe_system_error(on_error)

Get the current volume

Function Nameget_volume
Function Prototypeint get_volume()
Function OverviewGet the current volume of the audio-visual interaction system
ParametersNone
Return Valueint, volume value, range: 0~200
Note

C++ Example:

int volume = ctrl->get_volume();
std::cout << volume << std::endl;

Python Example:

volume = ctrl.get_volume()
print(volume)

Set the current volume

Function Nameset_volume
Function Prototypevoid set_volume(int volume)
Function OverviewSet the volume of the current audio-visual interaction system
Parametersvolume: volume value, range: 0~200
Return ValueNone
Note

C++ Example:

ctrl->set_volume(100);

Python Example:

ctrl.set_volume(100)

Get the inactivity timeout before entering sleep

Function Nameget_timeout
Function Prototypeint get_timeout()
Function OverviewGet the inactivity timeout before entering sleep
ParametersNone
Return Valueint, timeout (ms)
Note

C++ Example:

int timeout = ctrl->get_timeout();
std::cout << timeout << std::endl;

Python Example:

timeout = ctrl.get_timeout()
print(timeout)

Set the timeout for entering sleep mode when there is no response

Function Nameset_timeout
Function Prototypevoid set_timeout(int timeout)
Function OverviewSet the timeout for entering sleep mode when there is no response
Parameterstimeout: Timeout duration (in ms)
Return ValueNone
Note

C++ Example:

ctrl->set_timeout(3000);

Python Example:

ctrl.set_timeout(3000)

Check whether the prompt tone is enabled

Function Nameget_audio_cue_enable
Function Prototypebool get_audio_cue_enable()
Function OverviewObtain the enabled status of the prompt tone of the audio and video interaction system
ParametersNone
Return Valuebool
Note

C++ Example:

bool enabled = ctrl->get_audio_cue_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_audio_cue_enable()
print(enabled)

Set whether the prompt tone is enabled

Function Nameset_audio_cue_enable
Function Prototypevoid set_audio_cue_enable(bool enable)
Function OverviewSet whether the prompt sound of the audio-visual interaction system is enabled
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_audio_cue_enable(true);

Python Example:

ctrl.set_audio_cue_enable(True)

Get the enabled status of internal microphone audio stream input to the agent.

Function Nameget_internal_capture_audio_data_to_agent_enable
Function Prototypebool get_internal_capture_audio_data_to_agent_enable()
Function OverviewGet the enabled status of internal microphone audio stream input to the agent.
ParametersNone
Return Valuebool
Note

C++ Example:

bool enabled = ctrl->get_internal_capture_audio_data_to_agent_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_internal_capture_audio_data_to_agent_enable()
print(enabled)

Set the enabled status of internal microphone audio stream input to the agent.

Function Nameset_internal_capture_audio_data_to_agent_enable
Function Prototypevoid set_internal_capture_audio_data_to_agent_enable(bool enable)
Function OverviewSet whether the internal microphone is enabled to collect audio stream and input it to the agent
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_internal_capture_audio_data_to_agent_enable(true);

Python Example:

ctrl.set_internal_capture_audio_data_to_agent_enable(True)

Get the enabled status of external audio stream input to the agent.

Function Nameget_external_custom_audio_data_to_agent_enable
Function Prototypebool get_external_custom_audio_data_to_agent_enable()
Function OverviewGet the enabled status of external audio stream input for the agent
ParametersNone
Return Valuebool: true indicates enabled, false indicates disabled
Note

C++ Example:

bool enabled = ctrl->get_external_custom_audio_data_to_agent_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_external_custom_audio_data_to_agent_enable()
print(enabled)

Set the enabled status of external audio stream input to the agent.

Function Nameset_external_custom_audio_data_to_agent_enable
Function Prototypevoid set_external_custom_audio_data_to_agent_enable(bool enable)
Function OverviewSet whether the external audio stream input to the agent is enabled
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_external_custom_audio_data_to_agent_enable(true);

Python Example:

ctrl.set_external_custom_audio_data_to_agent_enable(True)

Get the enabled status of agent audio stream output to the internal speaker.

Function Nameget_internal_agent_audio_data_to_playback_enable
Function Prototypebool get_internal_agent_audio_data_to_playback_enable()
Function OverviewGet whether the agent audio stream output to the internal speaker is enabled
ParametersNone
Return Valuebool: true indicates enabled, false indicates disabled
Note

C++ Example:

bool enabled = ctrl->get_internal_agent_audio_data_to_playback_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_internal_agent_audio_data_to_playback_enable()
print(enabled)

Set the enabled status of agent audio stream output to the internal speaker.

Function Nameset_internal_agent_audio_data_to_playback_enable
Function Prototypevoid set_internal_agent_audio_data_to_playback_enable(bool enable)
Function OverviewSet whether the agent audio stream output to the internal speaker is enabled
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_internal_agent_audio_data_to_playback_enable(true);

Python Example:

ctrl.set_internal_agent_audio_data_to_playback_enable(True)

Get whether the external audio stream output to the internal speaker is enabled

Function Nameget_external_custom_audio_data_to_playback_enable
Function Prototypebool get_external_custom_audio_data_to_playback_enable()
Function OverviewGet the enabled status of outputting external audio stream to the internal speaker
ParametersNone
Return Valuebool type: true to enable, false to disable
Note

C++ Example:

bool enabled = ctrl->get_external_custom_audio_data_to_playback_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_external_custom_audio_data_to_playback_enable()
print(enabled)

Set the enabled status of external audio stream output to the internal speaker.

Function Nameset_external_custom_audio_data_to_playback_enable
Function Prototypevoid set_external_custom_audio_data_to_playback_enable(bool enable)
Function OverviewSet whether the external audio stream is output to the internal speaker
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_external_custom_audio_data_to_playback_enable(true);

Python Example:

ctrl.set_external_custom_audio_data_to_playback_enable(True)

Get the enabled status of internal video stream input to the agent.

Function Nameget_internal_capture_video_data_to_agent_enable
Function Prototypebool get_internal_capture_video_data_to_agent_enable()
Function OverviewObtain the enabled status of the internal video stream input to the agent
ParametersNone
Return Valuebool: true indicates enabled, false indicates disabled
Note

C++ Example:

bool enabled = ctrl->get_internal_capture_video_data_to_agent_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_internal_capture_video_data_to_agent_enable()
print(enabled)

Set the enabled status of internal video stream input to the agent.

Function Nameset_internal_capture_video_data_to_agent_enable
Function Prototypevoid set_internal_capture_video_data_to_agent_enable(bool enable)
Function OverviewSet whether to enable the internal video stream input for the agent
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_internal_capture_video_data_to_agent_enable(true);

Python Example:

ctrl.set_internal_capture_video_data_to_agent_enable(True)

Get the enabled status of external video stream input to the agent.

Function Nameget_external_custom_video_data_to_agent_enable
Function Prototypebool get_external_custom_video_data_to_agent_enable()
Function OverviewObtain the enabled status of the external video stream input to the agent
ParametersNone
Return Valuebool: true indicates enabled, false indicates disabled
Note

C++ Example:

bool enabled = ctrl->get_external_custom_video_data_to_agent_enable();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_external_custom_video_data_to_agent_enable()
print(enabled)

Set the enabled status of external video stream input to the agent.

Function Nameset_external_custom_video_data_to_agent_enable
Function Prototypevoid set_external_custom_video_data_to_agent_enable(bool enable)
Function OverviewSet whether the external video stream input to the agent is enabled
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_external_custom_video_data_to_agent_enable(true);

Python Example:

ctrl.set_external_custom_video_data_to_agent_enable(True)

Get the enabled status of using the internal 3A algorithm for external audio stream input to the agent.

Function Nameget_external_custom_audio_data_to_agent_use_internal_3a
Function Prototypebool get_external_custom_audio_data_to_agent_use_internal_3a()
Function OverviewObtain the status of whether the agent enables the internal 3A algorithm when receiving external audio stream input
ParametersNone
Return Valuebool: true indicates enabled, false indicates disabled
Note

C++ Example:

bool enabled = ctrl->get_external_custom_audio_data_to_agent_use_internal_3a();
std::cout << (enabled ? "true" : "false") << std::endl;

Python Example:

enabled = ctrl.get_external_custom_audio_data_to_agent_use_internal_3a()
print(enabled)

Set the enabled status of using the internal 3A algorithm for external audio stream input to the agent.

Function Nameset_external_custom_audio_data_to_agent_use_internal_3a
Function Prototypevoid set_external_custom_audio_data_to_agent_use_internal_3a(bool enable)
Function OverviewSet whether the external audio stream input to the agent uses the internal 3A algorithm
ParametersEnable: true on, false off
Return ValueNone
Note

C++ Example:

ctrl->set_external_custom_audio_data_to_agent_use_internal_3a(true);

Python Example:

ctrl.set_external_custom_audio_data_to_agent_use_internal_3a(True)

Get wake-up response words

Function Nameget_wakeup_response_words
Function Prototypestring get_wakeup_response_words()
Function OverviewGet wake-up response words
ParametersNone
Return Valuestring, the current wake-up reply word
Note

C++ Example:

std::string words = ctrl->get_wakeup_response_words();
std::cout << words << std::endl;

Python Example:

words = ctrl.get_wakeup_response_words()
print(words)

Set wake-up response words

Function Nameset_wakeup_response_words
Function Prototypevoid set_wakeup_response_words(string words)
Function OverviewSet wake-up response words
ParametersWords: Wake up the content of the reply message
Return ValueNone
Note

C++ Example:

ctrl->set_wakeup_response_words("我在");

Python Example:

ctrl.set_wakeup_response_words("我在")

Get dormant response words

Function Nameget_sleep_response_words
Function Prototypestring get_sleep_response_words()
Function OverviewGet dormant response words
ParametersNone
Return Valuestring,the current dormant response word
Note

C++ Example:

std::string words = ctrl->get_sleep_response_words();
std::cout << words << std::endl;

Python Example:

words = ctrl.get_sleep_response_words()
print(words)

Set sleep response words

Function Nameset_sleep_response_words
Function Prototypevoid set_sleep_response_words(string words)
Function OverviewSet up auto-reply messages for idle status
Parameterswords: content of the auto-reply for inactivity
Return ValueNone
Note

C++ Example:

ctrl->set_sleep_response_words("Okay, I'm going to rest first.");

Python Example:

ctrl.set_sleep_response_words("Okay, I'm going to rest first.")

Get wake-up words

Function Nameget_wakeup_words
Function Prototypestring get_wakeup_words()
Function OverviewGet all wake-up words
ParametersNone
Return Valuestring,all current wake words
Note

C++ Example:

std::string words = ctrl->get_wakeup_words();
std::cout << words << std::endl;

Python Example:

words = ctrl.get_wakeup_words()
print(words)

Add wake-up words

Function Nameadd_wakeup_words
Function Prototypebool add_wakeup_words(const std::string &words);
Function OverviewAdd a new wake word
Parameters- words: newly-wake word string
Return Valuebool:whether the addition via internal Regular Expression succeeded
NoteRegular Expression:(^(((([a-z]+) )?([^\s]+) ))+@(.+)$) [Pinyin (including initials and finals] @Corresponding name
Example: b ù m ī @Bu Mi

C++ Example:

if (ctrl->add_wakeup_words("b ù m ī @Bu Mi"))
std::cout << "Success" << std::endl;
else
std::cout << "Failed" << std::endl;

Python Example:

if ctrl.add_wakeup_words("b ù m ī @Bu Mi"):
print("Success")
else:
print("Failed")

Reset Wake-up words

Function Namereset_wakeup_words
Function Prototypevoid reset_wakeup_words();
Function OverviewReset default factory wake-up words
ParametersNone
Return ValueNone
Note

C++ Example:

ctrl->reset_wakeup_words();

Python Example:

ctrl.reset_wakeup_words()

Subscribe to the audio stream collected by the robot's internal microphone

Function Namesubscribe_internal_audio_capture
Function Prototypevoid subscribe_internal_audio_capture(AudiostreamCallback callback);
Function OverviewSubscribe to the audio stream collected by the robot's internal microphone
Parameters- callback:callback function for processing audio stream data
Return ValueNone
NoteThe collected data is 8-channel data: the first four channels correspond to the four microphones mounted on the top of Bumi, the fifth and sixth channels are reserved channels, and the seventh and eighth channels are for loudspeaker echo acquisition.

C++ Example:

ctrl->subscribe_internal_audio_capture(
[&](const media::AudioStream &stream) {
std::lock_guard<std::mutex> lk(mtx);
if (channels == 0) {
channels = stream.channels;
sample_rate = stream.sample_rate;
}
pcm.insert(pcm.end(), stream.audio_data.begin(),
stream.audio_data.end());
});

Python Example:

def on_audio(stream):
with lock:
if channels_ref[0] == 0:
channels_ref[0] = stream.channels
sample_rate_ref[0] = stream.sample_rate
pcm_all.extend(stream.audio_data)

ctrl.subscribe_internal_audio_capture(on_audio)

Subscribe to the audio stream played by the robot's internal speaker

Function Namesubscribe_internal_audio_playback
Function Prototypevoid subscribe_internal_audio_playback(AudiostreamCallback callback);
Function OverviewSubscribe to the audio stream played by the robot's internal speaker
Parameters- callback:callback function for processing audio stream data
Return ValueNone
NoteThe collected data is 2-channel data from the Bumi ontology speaker.

C++ Example:

ctrl->subscribe_internal_audio_playback(
[&](const media::AudioStream &stream) {
std::lock_guard<std::mutex> lk(mtx);
if (channels == 0) {
channels = stream.channels;
sample_rate = stream.sample_rate;
}
pcm.insert(pcm.end(), stream.audio_data.begin(),
stream.audio_data.end());
});

Python Example:

def on_audio(stream):
with lock:
if channels_ref[0] == 0:
channels_ref[0] = stream.channels
sample_rate_ref[0] = stream.sample_rate
pcm_all.extend(stream.audio_data)

ctrl.subscribe_internal_audio_playback(on_audio)

Subscribe to the video stream collected by the camera in the robot (only available for Bumi without computing board)

Function Namesubscribe_internal_video_capture
Function Prototypevoid subscribe_internal_video_capture(VideostreamCallback callback);
Function OverviewSubscribe to the video stream collected by the camera in the robot
Parameters- callback:Callback function for processing video stream data
Return ValueNone
NoteOnly Bumi models without computing power boards are available

C++ Example:

ctrl->subscribe_internal_video_capture(
[&](const media::VideoStream &stream) {
printf(
"[DEBUG] video frame: %ux%u format=%u data=%zu bytes\n",
stream.width, stream.height, stream.format,
stream.video_data.size());
if (got.exchange(true))
return;
save_video_frame("internal_video_capture", stream);
});

Python Example:

def on_video(stream):
if got.is_set():
return
result[0] = stream
got.set()

ctrl.subscribe_internal_video_capture(on_video)

Subscribe to the desensitized video stream processed by the audio-visual interaction system

Function Namesubscribe_internal_video_desensed
Function Prototypevoid subscribe_internal_video_desensed(VideostreamCallback callback);
Function OverviewSubscribe to the desensitized video stream processed by the audio-visual interaction system (Bumi equipped with a computing board needs to continuously publish the availability of external video streams)
Parameters- callback:Callback function for processing video stream data
Return ValueNone
NoteBumi equipped with a computing board needs to continuously stream external video first before it can be used

C++ Example:

ctrl->subscribe_internal_video_desensed(
[&](const media::VideoStream &stream) {
printf(
"[DEBUG] video frame: %ux%u format=%u data=%zu bytes\n",
stream.width, stream.height, stream.format,
stream.video_data.size());
if (got.exchange(true))
return;
save_video_frame("internal_video_desensed", stream);
});

Python Example:

def on_video(stream):
if got.is_set():
return
result[0] = stream
got.set()

ctrl.subscribe_internal_video_desensed(on_video)

Suspend the internal camera data acquisition of the robot

Function Namepause_video_capture
Function Prototypevoid pause_video_capture()
Function OverviewPause the internal camera Data Acquisition of the robot (only applicable to Bumi models without a computing power board)
ParametersNone
Return ValueNone
NoteOnly Bumi models without computing boards are available

C++ Example:

ctrl->pause_video_capture();

Python Example:

ctrl.pause_video_capture()

Resume internal camera Data Acquisition of the robot

Function Nameresume_video_capture
Function Prototypevoid resume_video_capture()
Function OverviewResume the internal camera Data Acquisition of the robot (only applicable to Bumi without a computing board)
ParametersNone
Return ValueNone
NoteOnly Bumi models without computing boards are available

C++ Example:

ctrl->resume_video_capture();

Python Example:

ctrl.resume_video_capture()

Publish external video streams to the Audio-visual interaction system

Function Namepublish_external_video_stream
Function Prototypevoid publish_external_video_stream(VideoStream stream)
Function OverviewPublish external video streams to the audio-visual interaction system
Parametersstream: VideoStream struct, containing video frame data
Return ValueNone
Note

C++ Example:

VideoStream stream;
// Populate stream data...
ctrl->publish_external_video_stream(stream);

Python Example:

stream = VideoStream()
#Populate stream data...
ctrl.publish_external_video_stream(stream)

Publish external audio stream input to the agent

Function Namepublish_external_audio_stream
Function Prototypevoid publish_external_audio_stream(AudioStream stream)
Function OverviewPublish external audio stream input to the agent
Parametersstream: AudioStream structure, which contains audio data
Return ValueNone
Note

C++ Example:

AudioStream stream;
// Populate stream data...
ctrl->publish_external_audio_stream(stream);

Python Example:

stream = AudioStream()
# Populate stream data...
ctrl.publish_external_audio_stream(stream)

Publish external audio stream output to the internal speaker

Function Namepublish_external_audio_playback_stream
Function Prototypevoid publish_external_audio_playback_stream(AudioStream stream)
Function OverviewPublish external audio stream output to the internal speaker
Parametersstream: AudioStream structure, which contains audio data
Return ValueNone
Note

C++ Example:

AudioStream stream;
// Populate stream data...
ctrl->publish_external_audio_playback_stream(stream);

Python Example:

stream = AudioStream()
# Populate stream data...
ctrl.publish_external_audio_playback_stream(stream)

Pause internal microphone audio stream capture

Function Namepause_audio_capture
Function Prototypevoid pause_audio_capture()
Function OverviewPause internal microphone audio stream capture
ParametersNone
Return ValueNone
Note

C++ Example:

ctrl->pause_audio_capture();

Python Example:

ctrl.pause_audio_capture()

Resume internal microphone audio stream capture

Function Nameresume_audio_capture
Function Prototypevoid resume_audio_capture()
Function OverviewResume internal microphone audio stream capture
ParametersNone
Return ValueNone
Note

C++ Example:

ctrl->resume_audio_capture();

Python Example:

ctrl.resume_audio_capture()

Pause the audio stream output of the internal speaker

Function Namepause_audio_playback
Function Prototypevoid pause_audio_playback()
Function OverviewPause the audio stream output of the internal speaker
ParametersNone
Return ValueNone
Note

C++ Example:

ctrl->pause_audio_playback();

Python Example:

ctrl.pause_audio_playback()

Resume the audio stream output of the internal speaker

Function Nameresume_audio_playback
Function Prototypevoid resume_audio_playback()
Function OverviewResume the audio stream output of the internal speaker
ParametersNone
Return ValueNone
Note

C++ Example:

ctrl->resume_audio_playback();

Python Example:

ctrl.resume_audio_playback()

(V)Demo Test Case​

The SDK provides two complete sample programs with identical functions, which are implemented in C++ and Python respectively:

  • C++: examples/cpp/example_media.cpp compile and run
./build/example_media <command> [args]
  • Python: examples/py/test_media.py run
python3 test_media.py <command> [args]

All output files are saved by default in the out/ folder of the SDK root directory.

Test Case List

  1. Obtain all common_config configuration information
python3 examples/py/test_media.py
./build/example_media
  1. Subscribe to the internal microphone to capture a 10-second audio stream
python3 examples/py/test_media.py internal_audio_capture
./build/example_media internal_audio_capture

Subscribe to the internal microphone, capture audio for 10 seconds, and save it to out/internal_audio_capture.wav

  1. Record the audio stream played by the internal speaker
python3 examples/py/test_media.py internal_audio_playback
./build/example_media internal_audio_playback

Subscribe to the internal speaker, collect data for 10 seconds, and save to out/internal_audio_playback.wav

  1. Input the wav audio file to the audio-visual interaction system agent
python3 examples/py/test_media.py external_audio_agent <wav>
./build/example_media external_audio_agent <wav>

Read the wav file, and based on the status of the switches set_internal_capture_audio_data_to_agent_enable and set_external_custom_audio_data_to_agent_enable then TO_WAKEUP to wake up the agent, then send the audio in 20ms chunks via publish_external_audio_stream , and resume the switch status after completion

  1. Publish external audio stream output to the internal speaker
python3 examples/py/test_media.py external_audio_playback <wav>
./build/example_media external_audio_playback <wav>

Read the wav file, convert it to 2-channel interleaved format, split it into 20ms chunks, and transmit them via publish_external_audio_playback_stream for playback

  1. Subscribe to the internal video stream to capture a frame (for models without computing boards)
python3 examples/py/test_media.py internal_video_capture
./build/example_media internal_video_capture

Subscribe to the internal video stream and capture a frame to save it toout/internal_video_capture.png

  1. Subscribe to the internal desensitized video stream to capture a frame of image
python3 examples/py/test_media.py internal_video_desensed
./build/example_media internal_video_desensed

Subscribe to the internal desensitized video stream and capture one frame to save it to out/internal_video_desensed.png

Models equipped with computing boards need to first send the external video stream to the agent, as shown in the example below

  1. Publish external video stream input to the audio-visual interaction program agent
python3 examples/py/test_media.py external_video_publish
./build/example_media external_video_publish

ffmpeg collect and publish /dev/video4(640x480 yuyv422 @30fps),through publish_external_video_stream

(VIII) Camera Information​

info

The camera hardware of the Bumi EDU version (BumiEDU_Pro, BumiEDU_MAX, BumiEDU_Tailor) is directly connected to the computing board, which can directly access the hardware interfaces on the computing board to obtain data.

Please refer to the following link for the Intel D435i camera routines: https://github.com/IntelRealSense/librealsense

For models with a computing board, if you want to use the camera, please close the official camera image transmission program first.

sudo systemctl stop noetix-video-capture.service # Disable image transmission service
sudo systemctl disable noetix-video-capture.service # Disable auto-start

sudo systemctl start noetix-video-capture.service # Enable image transmission service
sudo systemctl enable noetix-video-capture.service # Enable auto-start

(IX) Rapid Development​

All the following operations are performed on the Bumi computing board. The computing board already has the required compilation environment installed; alternatively, you can deploy the compilation environment using Docker.

For the development and deployment environment of the external plugin, please refer to: SDK compilation environment deployment process

info

Introduction to External Plugin Development
Since the motion control board of humanoid products is not open to the public, user programs cannot be directly deployed and run on the motion control board, so an additional computing carrier is required to execute user programs.

If the model purchased by the user is not equipped with a computing board, the "external plugin development" method shall be adopted: the user shall prepare the computing board or host by themselves, and connect to the Bumi rear interface via a network cable to communicate with the motion control board.

Since the motion control board only allows communication with the fixed IP of the original computing board, and the communication is based on the wired connection of the internal switch, the external plugin device needs to be configured with the same IP as the original computing board to simulate the original computing board and complete the access.

Wired connection computing board SSH login

ssh noetix@192.168.55.101

Wireless SSH login to the computing board (the wireless IP can be viewed in the Wi-Fi connection status on the mobile App, which corresponds to the Wi-Fi module of the motion control board used by the computing board)

ssh -p 2222 noetix@[robotWIFI-IP]

(I)SDK Directory Structure​

.
├── build.sh # Compilation script
├── CMakeLists.txt
├── config # configuration file
├── dds # DDS library files
├── examples # Example code
├── include
├── lib # Dynamic library files
├── LICENSE
├── policy # Model file
├── pybind # pybind file
└── README.md

(II)Docker Development Environment Image Deployment​

noetix_dds.tar.gz

Note: This image package is for the aarch64 architecture and can only be deployed on computers with the aarch64 architecture.

  1. Extract the Compressed Packet
tar -zxvf noetix_dds.tar.gz

After extraction, the Compressed Packet contains noetix_dds. tar development mirror file noetix_dds. yaml configuration deployment file

version: "3.8"

services:
noetix_dds:
image: noetix_dds:arm64
container_name: noetix_dds
network_mode: host
volumes:
- /home/noetix/work:/home/noetix/work:rw # Mount working directory
# /home/noetix/work The part before the colon should be changed to the user's working directory; create a directory named /home/noetix/work/.
stdin_open: true
tty: true

  1. Deployment
docker load -i noetix_dds.tar
docker images # Confirm that the noetix_dds arm64 image exists.
mkdir -p /home/noetix/work # Create a working directory; the user can choose it
docker compose -f noetix_dds.yaml up -d # deploy
docker ps # Check if noetix_dds exists.

  1. Enter the dock container
docker exec -it noetix_dds /bin/bash

You can start development by simply placing the DDS SDK in the working directory afterwards.

(III)Compile the SDK​

cd noetix_sdk_bumi
./build.sh # One-click compilation script

After a successful compile, executable files will be generated in the root directory of the SDK: example_low andexample_high and example_policy_walkmeanwhile, the pybind libraries highcontrol_py 以及 lowcontrol_py will be generated in the build directory for Python to call.

(IV)Launch the Program​

C++

cd noetix_sdk_bumi
sudo ./build/example_high #or sudo ./build/example_low

Python

cd noetix_sdk_bumi
python3 examples/py/test_low.py # python3 examples/py/test_high.py
caution

During the debugging process, please use the robot hanger throughout the whole process to avoid losses caused by out-of-control faulty programs.

(X) Common Issues and Notes​

  1. DDS Client Demo: Runtime Error (1)

ARM architecture:

error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory

libssl1.1_1.1.1f-1ubuntu2.16_arm64.deb

sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2.16_arm64.deb

Architecture:

error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory

libssl1.1_1.1.1f-1ubuntu2_amd64.deb

sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2_amd64.deb
©Beijing Noetix Robotics Technology Group Co., Ltd.
Jing ICP Bei No. 2024092119-1 | Jing Gong Wang An Bei No. 11010802045221
Internet Filing No. 110114067446901260013
Beijing-SongYanDongLiFangShengJiQiRen-20260901S0213
Beijing-SongYanDongLiRenXingJiQiRen-20260901S0214