Full-Body Examples

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),
            ])

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"

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"

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"

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"