> ## Documentation Index
> Fetch the complete documentation index at: https://innateinc-docs-skills-0-7-interface.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

```python theme={null}
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.

```python theme={null}
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.

```python theme={null}
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](/software/skills/code-defined-skills/composing-skills).

```python theme={null}
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](/software/skills/code-defined-skills/robot-state).

## GoHome

Return the arm and head to a safe configuration.

```python theme={null}
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"
```