(1) Objective: Sets the output percentage for the PWM port; the larger the value used, the longer the port will maintain a high level of output over the specified time period. (The basic frequency for the PWM port is 50Hz.)
(2) Type: Settings block
(3) Examples: Turn LED on/off, Rotate navigation gear
① Turn LED on/off
This enables you to connect an LED to any PWM port and then turn the LED on or off.

② Rotate navigation gear
This enables you to connect an external navigation gear to any PWM port and then control its rotation.

Notes:
1) PWM ports are located on the chassis control module. To access them, remove the transparent cover.

There are six PWM ports in total.

2) PWM (pulse width modulation) controls the duration of a high level of output during a certain period, and is broadly used to control LEDs, navigation gears, and more.
3) For LEDs, the PWM output rate ranges from 0% to 100%, with 0% corresponding to an LED’s lowest brightness and 100% to its highest brightness.
4) For navigation gears, the PWM output rate ranges from 2.5% to 12.5%. Because most navigation gears have a control impulse frequency of 50Hz and a control period of 20 ms, and because the high-level pulse width of outputs with an adjustable angle range of -90°to 90° ranges from 0.5ms to 2.5ms, control of the navigation gear’s duty ratio ranges from 0.5/20 to 2.5/20, which is to say from 2.5% to 12.5%.
You can set the navigation gear PWM output percentage based on the rotation angles you wish to control.

Python API:
Function: chassis_ctrl.set_pwm_value(pwm_port_enum, output_percent)
Parameters:
● pwm_port_enum(enum)
■ rm_define.pwm_all
■ rm_define.pwm1
■ rm_define.pwm2
■ rm_define.pwm3
■ rm_define.pwm4
■ rm_define.pwm5
■ rm_define.pwm6
● output_percent(int): [0, 100]

(1) Objective: Enables/disables the chassis accelerator
(2) Type: Settings block
(3) Example: Operate chassis accelerator When the chassis is moving automatically, this will enable you to use the joystick to manually rotate or translate the chassis and increase its translation speed.

Notes:
1) If the “Enable chassis accelerator” block has not been added, you will not be able to manually control the chassis while running the program. After adding this block, you will be able to manually control and accelerate the robot’s movements.
2) Joystick sensitivity refers to the push range of the joystick; the joystick’s sensitivity ranges from -1 to 1.
In the image below, the virtual joystick shown on the FPV interface has reached its upper limit, meaning its sensitivity value is 1.

3) When the chassis accelerator is enabled, the programmed speed will be added to the current speed.
As the image below shows, the chassis translates at a programmed speed of 0.5 m/s. When the joystick is pushed to its limit and the chassis accelerator is enabled, the robot will add the two speeds together and translate in a forward direction at a total speed of 1.5 m/s (0.5 m/s + 1 * the joystick’s maximum speed).

Python API:
Function: chassis_ctrl.enable_stick_overlay()
chassis_ctrl.disable_stick_overlay()

(1) Objective: In Gimbal Lead Mode, maintains a specific angle for the chassis relative to the movement of the gimbal
(2) Type: Settings block
(3) Example: Gimbal Lead Mode
The angle between the chassis and the movement of the gimbal will increase at first, then eventually fall to zero.

Notes:
1)This block will not work in Chassis Lead Mode or in Free Mode.
2)A zero-degree angle between the chassis and the movement of the gimbal means that the chassis and the gimbal are rotating in the same direction along the yaw axis.

Python API:
Function: chassis_ctrl. set_follow_gimbal_offset(degree)
Parameters:
● degree(int): [-180, 180]°

(1) Objective: Sets the default translation speed of the chassis to 0.5 m/s; the chassis will move faster when set to a higher speed value.
(2) Type: Settings block
(3) Example: Reduce reversal speed
This will control the chassis to translate forward at 1 m/s for 1.5 seconds, then translate backwards at 0.5 m/s for three seconds to return to the starting point.

Note:
Please ensure there are no obstacles in the robot’s intended path before setting the chassis to a high translation speed.

Python API:
Function: chassis_ctrl.set_trans_speed(speed)
Parameters:
● speed(float): [0, 3.5] m/s

(1) Objective: Sets the default rotation speed of the chassis to 30°/s; the chassis will rotate faster when set to a higher rotation speed value.
(2) Type: Settings block
(3) Example: Set acceleration warning
As the warning LED color changes, the rotation of the chassis will accelerate.

Python API:
Function: chassis_ctrl.set_rotate_speed(speed)
Parameters:
● speed(int): [0, 600]°/s

(1) Objective: Allows each wheel’s rotation speed to be set independently; only valid combinations of rotation direction and speed will take effect.
(2) Type: Execution block
(3) Examples: Reversing in an “S” pattern, Translating in a circle
① Reversing in an “S” pattern This will control the chassis to move backwards along an S-shaped path.

② Translating in a circle
This will control the robot to translate along a circular path.

Notes:
1) The robot will translate forward at the default rotation speed of 100 rpm for the front-left wheel, 100 rpm for the front-right wheel, 100 rpm for the rear-left wheel, and 100 rpm for the rear-right wheel.

2) To determine a valid combination of wheel rotation directions and speeds, push the robot manually to move it in the desired pattern and observe the rotational direction of each wheel; the rotation speed’s value should be positive for wheels rotating forward and negative for wheels rotating backward.
For example:
When the robot translates to the right, the front-left wheel and rear-right wheel will rotate forward, so their rotation speed values should be positive, while the front-right wheel and the rear-left wheel will rotate backward, so their rotation speed values should be negative.

When the robot translates backward and to the left, the front-left wheel and the rear-right wheel will rotate backward, so their rotation speed values should be negative, while the front-right wheel and the rear-left wheel will stay still, so their rotation speed values should be zero.

When the robot rotates to the left, the front-right wheel and the rear-right wheel will rotate forward, so their rotation speed values should be positive, while the front-left wheel and the rear-left wheel will rotate backwards, so their rotation speed values should be negative.

Python API:
Function: chassis_ctrl.set_wheel_speed(lf_speed, rf_speed, lr_speed, rr_speed)
Parameters:
● lf_speed(int): [-1000, 1000] rpm
● rf_speed(int): [-1000, 1000] rpm
● lr_speed(int): [-1000, 1000] rpm
● rr_speed(int): [-1000, 1000] rpm

(1) Objective: Sets the chassis to translate in a specified direction
(2) Type: Execution block
(3) Example: Make a round trip
This will control the S1 to translate forward for one second, then turn around and return to the starting point.

Note:
This block will control the chassis to continuously translate in a specified direction until the robot receives a “set chassis to stop moving,” ”wait (1) s,“ or other command that controls it to stop.

Python API:
Function: chassis_ctrl.move(degree)
Parameters:
● degree (int): [-180, 180]°

(1) Objective: Sets the duration of time the chassis will translate in a specified direction
(2) Type: Execution block
(3) Example: Translate in an X-pattern
This will control the robot to translate to the right, forward-left, right, and backward-left in an X-shaped sequence.

Python API:
Function: chassis_ctrl.move_with_time(degree, time)
Parameters:
● degree(int): [-180, 180]°
● time(float): [0, 20] s

(1) Objective: Sets the distance the chassis will translate in a specified direction
(2) Type: Execution block
(3) Example: Translate in a cross-pattern
This will control the robot to translate forward, backward, left and right in a cross-shaped sequence.

Python API:
Function: chassis_ctrl.move_with_distance(degree, distance)
Parameters:
● degree(int): [-180, 180]°
● distance(float): [0, 5] m

(1) Objective: Sets the chassis to translate in a specified direction and at a specified speed
(2) Type: Execution block
(3) Example: Return to starting position
This sets the chassis to translate forward and to the right at 1 m/s, then translate backward and to the left at 0.5 m/s to return to the original position.

Python API:
Function: chassis_ctrl.move_degree_with_speed(speed, degree)
Parameters:
● speed(float): [0, 3.5] m/s
● degree(int): [-180, 180]°

(1) Objective: Sets the chassis to rotate in a specified direction
(2) Type: Execution block
(3) Example: Rotate at variable speed This will control the chassis to rotate increasingly quickly to the right.

Note:
1) This block is not available in Gimbal Lead Mode.
2) Be sure there are no obstacles around the robot before setting a high chassis rotation speed.
3) This block will set the chassis to rotate constantly in a specified direction until it receives a “set chassis to stop moving”,“wait (1) s” or other command that causes it to stop.

Python API:
Function: chassis_ctrl.rotate(direction_enum)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise

(1) Objective: Sets the duration the chassis will rotate in a specified direction
(2) Type: Execution block
(3) Example: Cross-rotate the gimbal and chassis

Note:
This block is not available in Gimbal Lead Mode.

Python API:
Function: chassis_ctrl.rotate_with_time(direction_enum, time)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
● time(float): [0, 20] s

(1) Objective: Sets the angle and direction of chassis rotation
(2) Type: Execution block
(3) Example: Translate continuously back and forth This sets the S1 to translate back and forth continuously with the gimbal directed outward.

Note:
This block is not available in Gimbal Lead Mode.

Python API:
Function: chassis_ctrl.rotate_with_degree(direction_enum, degree)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
● degree(int): [0, 1800]°

(1) Objective: Sets the chassis to move in a specified direction while rotating simultaneously
(2) Type: Execution block
(3) Example: Translate in a figure-8 pattern
This sets the robot to translate in a figure-8.

Note:
The “set the robot to rotate” block is not available in Gimbal Lead Mode; however, the “set the robot to translate” block is supported in Gimbal Lead Mode.

Python API:
Function: chassis_ctrl.move_and_rotate(degree, direction_enum)
Parameters:
● degree(int): [-180, 180]°
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise

(1) Objective: Sets the chassis to translate in a specified direction and at a specified speed
(2) Type: Execution block
(3) Example: Translate in a circle with the gimbal aimed toward the central point

Python API:
Function: chassis_ctrl.move_with_speed(speed_x, speed_y, speed_rotation)
Parameters:
● speed_x(float): [0, 3.5] m/s
● speed_y(float): [0, 3.5] m/s
● speed_rotation(int): [-600, 600]°/s

(1) Objective: Stops all chassis movements
(2) Type: Execution block
(3) Example: Rotate chassis right
This sets the chassis to translate forward for 2 seconds at default speed, then turn right and stop moving

Python API:
Function: chassis_ctrl.stop()

(1) Objective: Obtains the current pitch angle for the chassis along its current yaw/pitch/roll axes based on the chassis location when the robot begins running
(2) Type: Information block (variable-type)
(3) Example: Signal turn
This sets the yellow LED indicator to come on when you manually control the robot to turn left, and sets the blue LED indicator to come on when you manually control the robot to turn right.

Note:
1) Rotating the chassis along the yaw axis results in left and right rotation.

2)Rotating the chassis along the pitch axis results in up and down rotation.

3) Rotating the chassis along the roll axis will cause the robot to turn over.

Python API:
Function: chassis_ctrl.get_attitude(attitude_enum)
Parameters:
● attitude_enum(enum):
■ rm_define.chassis_yaw
■ rm_define.chassis_pitch
■ rm_define.chassis_roll
Return value:
● degree(float)

(1) Objective: Obtains the current location coordinates and orientation of the chassis
(2) Type: Information block (variable-type)
(3) Example: Obtain current position information This enables you to check numerical data for the current chassis position by manually pushing the robot back and forth or turning it left and right.

You can observe numerical changes using the FPV interface.

Note:
Because the chassis is under closed-loop control, it is normal to feel some resistance when moving the robot manually.

Python API:
Function: chassis_ctrl.get_position_based_power_on(action_enum)
Parameters:
● action_enum(enum):
■ rm_define.chassis_forward
■ rm_define.chassis_translation
■ rm_define.chassis_rotate
Return value:
● position(float)

(1) Objective: Runs the program for the corresponding block when the chassis hits an obstacle while driving
(2) Type: Event block
(3) Example: Self-defend
This enables the self-defense mechanism to activate when the chassis impacts an obstacle, causing the robot to retreat and stop running the block.

Python API:
Function: def chassis_impact_detection(msg)
Type: Event callback

(1) Objective: Returns “True” when the chassis hits an obstacle while driving; otherwise, returns “False”
(2) Type: Boolean block
(3) Example: Emit danger warning If the chassis impacts an obstacle while the robot is being controlled through the FPV interface, the “hit” sound will play and all red LED indicators for the chassis and gimbal will blink; in all other scenarios,these indicators will remain on in a steadystate.

Python API:
Function:chassis_ctrl.is_impact()
Return value:
● impact_status(bool)