Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.innate.bot/llms.txt

Use this file to discover all available pages before exploring further.

The ManipulationInterface and HeadInterface give you direct control over the robot’s arm and head. Use these for manipulation tasks, gestures, and camera positioning.

​
ManipulationInterface

Declare the interface at class level: 
from brain_client.skill_types import Skill, Interface, InterfaceType

class MySkill(Skill):
    manipulation = Interface(InterfaceType.MANIPULATION)

​
Methods

MethodParametersDescription
move_to_cartesian_pose()
x: floaty: floatz: floatroll: floatpitch: floatyaw: floatduration: float
Move the end-effector to a target Cartesian pose.
goto_joint_state()
joints: list[float]
Move the arm to a target joint configuration (6 values).
get_current_orientation_rpy()NoneGet current end-effector orientation as roll/pitch/yaw values.
get_current_end_effector_pose()NoneGet current end-effector pose (position + quaternion).
solve_ik()
x: floaty: floatz: floatroll: floatpitch: floatyaw: floattimeout: float
Solve inverse kinematics for a target pose without moving the arm.

​
Cartesian Control

Move the end-effector to a specific position and orientation: 
# Move to position (x, y, z) with orientation (roll, pitch, yaw)
self.manipulation.move_to_cartesian_pose(
    x=0.2, y=0.0, z=0.3,
    roll=0.0, pitch=0.0, yaw=0.0,
    duration=2.0
)

​
Joint Control

Move directly to joint angles (6 joints): 
# Move to joint configuration [j1, j2, j3, j4, j5, j6]
self.manipulation.goto_joint_state([0, -0.5, 1.5, -1.0, 0, 0])

​
Reading State

# Get current end-effector pose
pose = self.manipulation.get_current_end_effector_pose()
# Returns: {'position': [x, y, z], 'orientation': [qx, qy, qz, qw]}

# Get orientation as roll/pitch/yaw
rpy = self.manipulation.get_current_orientation_rpy()
# Returns: {'roll': r, 'pitch': p, 'yaw': y}

​
Inverse Kinematics

Check if a pose is reachable before moving: 
joints = self.manipulation.solve_ik(
    x=0.2, y=0.0, z=0.3,
    roll=0.0, pitch=0.0, yaw=0.0,
    timeout=1.0
)
if joints:
    self.manipulation.goto_joint_state(joints)
else:
    return "Pose unreachable", SkillResult.FAILURE

​
HeadInterface

Control camera tilt: 
from brain_client.skill_types import Skill, Interface, InterfaceType

class MySkill(Skill):
    head = Interface(InterfaceType.HEAD)

​
Methods

MethodParametersDescription
set_position()
angle: int
Set head tilt angle (from -25deg to +15deg).

​
Tilt Angles

AngleView
-25degFloor and objects below.
0degStraight ahead.
+15degFaces and shelves above.
self.head.set_position(-15)  # Look down at objects
self.head.set_position(0)    # Look straight ahead
self.head.set_position(10)   # Look up at faces

​
Example: Wave

A skill that waves the arm: 
from brain_client.skill_types import Skill, SkillResult, Interface, InterfaceType
import time

class Wave(Skill):
    manipulation = Interface(InterfaceType.MANIPULATION)

    @property
    def name(self):
        return "wave"

    def guidelines(self):
        return "Use to wave at someone in greeting."

    def execute(self, times: int = 3):
        # Wave positions
        wave_left = [0.5, -0.3, 1.0, -0.5, 0.5, 0]
        wave_right = [0.5, -0.3, 1.0, -0.5, -0.5, 0]

        for i in range(times):
            if self._cancelled:
                return "Wave cancelled", SkillResult.CANCELLED

            self.manipulation.goto_joint_state(wave_left)
            time.sleep(0.3)
            self.manipulation.goto_joint_state(wave_right)
            time.sleep(0.3)

        return f"Waved {times} times", SkillResult.SUCCESS

    def cancel(self):
        self._cancelled = True
        return "Wave cancelled"

​
Example: LookAtObject

A skill that adjusts head to look at objects: 
from brain_client.skill_types import Skill, SkillResult, Interface, InterfaceType

class LookAtObject(Skill):
    head = Interface(InterfaceType.HEAD)

    @property
    def name(self):
        return "look_at_object"

    def guidelines(self):
        return "Use to tilt camera to look at objects on the floor or shelves."

    def execute(self, location: str = "floor"):
        angles = {
            "floor": -25,
            "table": -10,
            "ahead": 0,
            "face": 10,
            "shelf": 15
        }

        angle = angles.get(location, 0)
        self.head.set_position(angle)

        return f"Looking at {location}", SkillResult.SUCCESS

    def cancel(self):
        return "Cannot cancel head movement"