Full-Body Examples

Complete examples that combine navigation, manipulation, and sensor data into full-body robot behaviors.

Read them for the shape as much as the content: no __init__, no None guards, no _cancelled flags, no result tuples, no cancel() methods. Everything the skill consumes is one annotation, and cancellation is the framework’s job.

ScanAndWave

Rotate to find a person, then wave.

import math

from innate import Head, MainImage, Manipulation, Mobility, Skill, Waypoint


class ScanAndWave(Skill):
    """Rotate to scan for people and wave when one is found. Use when
    greeting someone in the room."""

    mobility: Mobility
    manipulation: Manipulation
    head: Head
    image: MainImage

    def execute(self, directions: int = 8):
        self.head.set_position(10)          # look up, at face height
        self.sleep(0.5)

        for i in range(directions):
            self.feedback(f"Scanning direction {i + 1}/{directions}")

            if self._looks_like_a_person(self.image):
                self._wave()
                return "Found someone and waved"

            self.mobility.rotate(2 * math.pi / directions)

        return "No one around"

    def _looks_like_a_person(self, image: MainImage) -> bool:
        # Stubbed on purpose — swap in your own detector. `image` is already
        # the base64 JPEG a vision API wants; `image.jpeg` gives raw bytes.
        return False

    def _wave(self):
        for _ in range(3):
            self.manipulation.follow([
                Waypoint(x=0.22, y=0.10, z=0.30, duration=0.35),
                Waypoint(x=0.22, y=-0.10, z=0.30, duration=0.35),
            ])

mobility.rotate() and the arm motions are all blocking, so they double as cancel points — a Stop raises out of whichever one is running and the framework brakes the base, halts the arm, and reports CANCELLED.

PickupRoutine

Position the robot and the arm for a pickup.

from innate import Head, Manipulation, Mobility, Skill


class PickupRoutine(Skill):
    """Position the robot and arm to pick up an object in front of it. Use
    before a grasp, when the object is roughly ahead of the robot."""

    mobility: Mobility
    manipulation: Manipulation
    head: Head

    READY = (0.28, 0.0, 0.22)

    def execute(self, approach_distance: float = 0.3):
        self.feedback("Folding the arm away for the approach")
        self.manipulation.rest()

        self.feedback("Looking at the target area")
        self.head.set_position(-20)

        self.feedback("Approaching")
        self.mobility.send_cmd_vel(linear_x=0.05, duration=approach_distance / 0.05)
        self.sleep(approach_distance / 0.05)

        self.feedback("Raising the arm")
        self.manipulation.move_to(*self.READY, pitch=1.2, duration=1.5)
        self.manipulation.gripper_open()

        return "Ready for pickup"

The send_cmd_vel + self.sleep pair is deliberate: the command carries a deadman duration, so the base halts on its own if the skill dies, and the sleep is what makes the wait interruptible.

PatrolAndMonitor

Rotate between headings, sweeping the head and capturing frames at each one.

import math
import time

from innate import Head, MainImage, Mobility, Skill


class PatrolAndMonitor(Skill):
    """Rotate through several headings and capture the view at each, for a
    duration. Use for surveillance sweeps of a room."""

    mobility: Mobility
    head: Head
    image: MainImage

    def execute(self, positions: int = 4, duration: float = 30.0):
        images = []
        deadline = time.monotonic() + duration
        step = 2 * math.pi / positions

        while time.monotonic() < deadline:
            for _ in range(positions):
                for angle in (-15, 0, 10):
                    self.head.set_position(angle)
                    self.sleep(0.5)
                    images.append(str(self.image))
                    self.feedback(f"Captured image {len(images)}")

                self.mobility.rotate(step)

        return f"Patrol complete — captured {len(images)} images"

FetchFromRoom

Drive somewhere, run a trained policy, and come back — a routine assembled entirely from sub-skills.

from innate import Pose, Skill
from innate.exceptions import SkillFailed
from innate_skills.arm_rest_position import ArmRestPosition
from innate_skills.navigate_to_position import NavigateToPosition
from physical_skills import PickSocks


class FetchFromRoom(Skill):
    """Drive to a map position, try to pick up a sock there, and return to
    where the robot started. Use when asked to fetch something from
    another room."""

    pose: Pose
    navigate: NavigateToPosition
    pick: PickSocks
    arm_rest: ArmRestPosition

    def execute(self, x: float, y: float):
        home_x, home_y = self.pose.position

        self.navigate(x=x, y=y, timeout=180)

        try:
            self.pick(timeout=60)
            picked = True
        except SkillFailed:
            picked = False

        self.arm_rest()
        self.navigate(x=home_x, y=home_y, timeout=180)

        return "Fetched it and came back" if picked else "Couldn't pick it up, came back empty"

pose is the map-frame position, which is the right frame to remember and drive back to. Use odom for relative moves instead — see Robot state.

GoHome

Return the arm and head to a safe configuration.

from innate import Head, Manipulation, Skill


class GoHome(Skill):
    """Return the arm and head to their home positions. Use to tidy up after a
    task — safe while holding something, since the grip is preserved."""

    manipulation: Manipulation
    head: Head

    def execute(self):
        self.feedback("Folding the arm")
        self.manipulation.rest()

        self.feedback("Centering the head")
        self.head.set_position(0)

        return "Home position reached"