Spaces:

itsMarco-G
/

reachy_phone_home

Running

App Files Files Community

itsMarco-G commited on 17 days ago

Commit

3e090ab

1 Parent(s): 858f68f

Initial commit

Browse files

Files changed (22) hide show

.DS_Store +0 -0
.hfignore +4 -0
README.md +36 -0
index.html +41 -0
pyproject.toml +13 -0
reachy_phone_home.egg-info/PKG-INFO +45 -0
reachy_phone_home.egg-info/SOURCES.txt +13 -0
reachy_phone_home.egg-info/dependency_links.txt +1 -0
reachy_phone_home.egg-info/entry_points.txt +2 -0
reachy_phone_home.egg-info/requires.txt +1 -0
reachy_phone_home.egg-info/top_level.txt +1 -0
reachy_phone_home/__init__.py +0 -0
reachy_phone_home/__pycache__/__init__.cpython-310.pyc +0 -0
reachy_phone_home/__pycache__/expressions.cpython-310.pyc +0 -0
reachy_phone_home/__pycache__/gestures.cpython-310.pyc +0 -0
reachy_phone_home/__pycache__/main.cpython-310.pyc +0 -0
reachy_phone_home/__pycache__/movements.cpython-310.pyc +0 -0
reachy_phone_home/main.py +382 -0
reachy_phone_home_app.py +456 -0
setup.cfg +12 -0
setup.py +3 -0
style.css +98 -0

.DS_Store ADDED Viewed

Binary file (6.15 kB). View file

.hfignore ADDED Viewed

	@@ -0,0 +1,4 @@

+.DS_Store
+reachy_mini_demos/
+utils/
+yolo26l.pt

README.md ADDED Viewed

	@@ -0,0 +1,36 @@

+---
+title: Reachy Phone Home
+emoji: 📱
+colorFrom: yellow
+colorTo: blue
+sdk: static
+pinned: false
+short_description: Phone focus companion for Reachy Mini
+tags:
+  - reachy_mini
+  - reachy_mini_python_app
+---
+# reachy_phone_home
+Phone focus companion for Reachy Mini. Reachy watches for your phone, encourages focus, and responds with movements.
+## How it works
+- Uses Reachy Mini camera + YOLO phone/person detection.
+- Tracks phone use and triggers movements after configured heartbeats.
+- Includes a manual simulation app for development.
+## Run locally
+```bash
+python reachy_phone_home_app.py --weights yolo26l
+```
+The YOLO26 weights are downloaded automatically on first run.
+## Configure
+Key flags (examples):
+```bash
+python reachy_phone_home_app.py --weights yolo26l --conf 0.15 --process-every 1
+```
+## Publishing
+Use the Reachy Mini App Assistant to check and publish this app.

index.html ADDED Viewed

	@@ -0,0 +1,41 @@

+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Reachy Phone Home</title>
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <main class="page">
+      <header class="hero">
+        <div class="badge">Reachy Mini App</div>
+        <h1>Reachy Phone Home</h1>
+        <p>
+          A focus companion for Reachy Mini. Place your phone in front of Reachy and keep
+          it there while you work. Reachy watches for the phone, reacts to use, and
+          nudges you back to focus.
+        </p>
+        <div class="cta">
+          <span>Run locally:</span>
+          <code>python reachy_phone_home_app.py --weights yolo26l</code>
+        </div>
+      </header>
+      <section class="grid">
+        <div class="card">
+          <h2>Phone Watch</h2>
+          <p>Detects phone and person, then tracks phone use with stable timing.</p>
+        </div>
+        <div class="card">
+          <h2>Reachy Motions</h2>
+          <p>Triggers “good job” movements after steady focus and “bad” movements after use.</p>
+        </div>
+        <div class="card">
+          <h2>Customizable</h2>
+          <p>Tune thresholds and timing via CLI flags to fit your space and camera setup.</p>
+        </div>
+      </section>
+    </main>
+  </body>
+</html>

pyproject.toml ADDED Viewed

	@@ -0,0 +1,13 @@

+[project]
+name = "reachy_phone_home"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "reachy-mini"
+]
+keywords = ["reachy-mini-app"]
+[project.entry-points."reachy_mini_apps"]
+reachy_phone_home = "reachy_phone_home.main:ReachyPhoneHome"

reachy_phone_home.egg-info/PKG-INFO ADDED Viewed

	@@ -0,0 +1,45 @@

+Metadata-Version: 2.4
+Name: reachy_phone_home
+Version: 0.1.0
+Summary: Add your description here
+Keywords: reachy-mini-app
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: reachy-mini
+---
+title: Reachy Phone Home
+emoji: 📱
+colorFrom: yellow
+colorTo: blue
+sdk: static
+pinned: false
+short_description: Phone focus companion for Reachy Mini
+tags:
+  - reachy_mini
+  - reachy_mini_python_app
+---
+# reachy_phone_home
+Phone focus companion for Reachy Mini. Reachy watches for your phone, encourages focus, and responds with movements.
+## How it works
+- Uses Reachy Mini camera + YOLO phone/person detection.
+- Tracks phone use and triggers movements after configured heartbeats.
+- Includes a manual simulation app for development.
+## Run locally
+```bash
+python reachy_phone_home_app.py --weights yolo26l
+```
+The YOLO26 weights are downloaded automatically on first run.
+## Configure
+Key flags (examples):
+```bash
+python reachy_phone_home_app.py --weights yolo26l --conf 0.15 --process-every 1
+```
+## Publishing
+Use the Reachy Mini App Assistant to check and publish this app.

reachy_phone_home.egg-info/SOURCES.txt ADDED Viewed

	@@ -0,0 +1,13 @@

+README.md
+pyproject.toml
+setup.cfg
+setup.py
+reachy_phone_home/__init__.py
+reachy_phone_home/main.py
+reachy_phone_home/movements.py
+reachy_phone_home.egg-info/PKG-INFO
+reachy_phone_home.egg-info/SOURCES.txt
+reachy_phone_home.egg-info/dependency_links.txt
+reachy_phone_home.egg-info/entry_points.txt
+reachy_phone_home.egg-info/requires.txt
+reachy_phone_home.egg-info/top_level.txt

reachy_phone_home.egg-info/dependency_links.txt ADDED Viewed

	@@ -0,0 +1 @@


1	+

reachy_phone_home.egg-info/entry_points.txt ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ [reachy_mini_apps]
2	+ reachy_phone_home = reachy_phone_home.main:ReachyPhoneHome

reachy_phone_home.egg-info/requires.txt ADDED Viewed

	@@ -0,0 +1 @@


1	+ reachy-mini

reachy_phone_home.egg-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@


1	+ reachy_phone_home

reachy_phone_home/__init__.py ADDED Viewed

File without changes

reachy_phone_home/__pycache__/__init__.cpython-310.pyc ADDED Viewed

Binary file (182 Bytes). View file

reachy_phone_home/__pycache__/expressions.cpython-310.pyc ADDED Viewed

Binary file (2.5 kB). View file

reachy_phone_home/__pycache__/gestures.cpython-310.pyc ADDED Viewed

Binary file (6.77 kB). View file

reachy_phone_home/__pycache__/main.cpython-310.pyc ADDED Viewed

Binary file (10.3 kB). View file

reachy_phone_home/__pycache__/movements.cpython-310.pyc ADDED Viewed

Binary file (6.07 kB). View file

reachy_phone_home/main.py ADDED Viewed

	@@ -0,0 +1,382 @@

+import argparse
+import itertools
+import os
+import queue
+import random
+import sys
+import tempfile
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from hashlib import sha1
+from typing import Iterable, List, Optional, Tuple
+from reachy_mini import ReachyMini, ReachyMiniApp
+try:
+    from .movements import Movement, SituationMovements
+except ImportError:  # allow running as a script
+    import sys
+    from pathlib import Path
+    sys.path.append(str(Path(__file__).resolve().parents[1]))
+    from reachy_phone_home.movements import Movement, SituationMovements
+@dataclass
+class SimulationConfig:
+    ambient_interval: float = 5.0
+    good_job_interval: float = 10.0
+    bad_interval: float = 5.0
+    min_gap_seconds: float = 5.0
+class ElevenLabsSpeaker:
+    def __init__(
+        self,
+        reachy: ReachyMini,
+        voice_id: str,
+        model_id: str = "eleven_multilingual_v2",
+        output_format: str = "pcm_22050",
+        cache_dir: Optional[Path] = None,
+    ) -> None:
+        self.reachy = reachy
+        self.voice_id = voice_id
+        self.model_id = model_id
+        self.output_format = output_format
+        self.cache_dir = cache_dir
+        self._client = None
+    def _ensure_client(self) -> None:
+        if self._client is not None:
+            return
+        try:
+            from elevenlabs.client import ElevenLabs
+        except ImportError as exc:
+            raise SystemExit("Missing dependency: pip install elevenlabs") from exc
+        api_key = os.getenv("ELEVENLABS_API_KEY")
+        if not api_key:
+            raise SystemExit("ELEVENLABS_API_KEY is not set.")
+        self._client = ElevenLabs(api_key=api_key)
+    def _cache_path(self, text: str) -> Optional[Path]:
+        if self.cache_dir is None:
+            return None
+        key = f"{self.voice_id}|{self.model_id}|{self.output_format}|{text}"
+        digest = sha1(key.encode("utf-8")).hexdigest()[:12]
+        safe = "".join(ch for ch in text.lower() if ch.isalnum() or ch in (" ", "-"))
+        safe = "_".join(safe.split())[:32]
+        filename = f"{safe or 'quip'}_{digest}.wav"
+        return self.cache_dir / filename
+    def say(self, text: str) -> None:
+        if self.output_format.startswith("pcm_"):
+            sample_rate = int(self.output_format.split("_", 1)[1])
+        else:
+            raise SystemExit("Only PCM output is supported for now.")
+        cache_path = self._cache_path(text)
+        if cache_path is not None and cache_path.exists():
+            self.reachy.media.play_sound(str(cache_path))
+            return
+        self._ensure_client()
+        assert self._client is not None
+        audio = self._client.text_to_speech.convert(
+            text=text,
+            voice_id=self.voice_id,
+            model_id=self.model_id,
+            output_format=self.output_format,
+        )
+        audio_bytes = audio if isinstance(audio, (bytes, bytearray)) else b"".join(audio)
+        if cache_path is not None:
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+            _write_pcm_wav(cache_path, audio_bytes, sample_rate)
+            self.reachy.media.play_sound(str(cache_path))
+            return
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            wav_path = Path(tmp_dir) / "tts.wav"
+            _write_pcm_wav(wav_path, audio_bytes, sample_rate)
+            self.reachy.media.play_sound(str(wav_path))
+def _write_pcm_wav(path: Path, pcm_bytes: bytes, sample_rate: int) -> None:
+    import wave
+    with wave.open(str(path), "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(pcm_bytes)
+def _start_key_listener(stop_event: threading.Event) -> queue.Queue[str]:
+    q: queue.Queue[str] = queue.Queue()
+    def _reader() -> None:
+        if not sys.stdin.isatty():
+            return
+        import select
+        import termios
+        import tty
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        try:
+            tty.setcbreak(fd)
+            while not stop_event.is_set():
+                r, _, _ = select.select([sys.stdin], [], [], 0.1)
+                if r:
+                    ch = sys.stdin.read(1)
+                    q.put(ch)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    t = threading.Thread(target=_reader, daemon=True)
+    t.start()
+    return q
+class ReachyPhoneHome(ReachyMiniApp):
+    def __init__(self, config: SimulationConfig | None = None) -> None:
+        super().__init__()
+        self.config = config or SimulationConfig()
+        self.enable_tts = True
+        self.voice_id = "KiWrnassWh6wLlOzZhGd"
+        self.model_id = "eleven_multilingual_v2"
+        self.output_format = "pcm_22050"
+        self.cache_dir: Optional[Path] = None
+    def _cycle_movements(self, moves: Iterable[Movement]) -> Iterable[Movement]:
+        return itertools.cycle(list(moves))
+    def _play_next(
+        self,
+        cycle_iter: Iterable[Movement],
+        label: str,
+        speaker: Optional[ElevenLabsSpeaker] = None,
+        quips: Optional[List[str]] = None,
+    ) -> None:
+        move = next(cycle_iter)
+        print(f"[{label}] {move.name}")
+        move.run()
+        if speaker and quips:
+            speaker.say(random.choice(quips))
+    def _run_state_loop(
+        self,
+        stop_event: threading.Event,
+        ambient: Iterable[Movement],
+        good_job: Iterable[Movement],
+        bad: Iterable[Movement],
+        speaker: Optional[ElevenLabsSpeaker],
+        placed_quips: List[str],
+        taken_quips: List[str],
+        good_quips: List[str],
+        bad_quips: List[str],
+    ) -> None:
+        phone_present = False
+        print("\nPress 1 = phone placed, 2 = phone taken, Ctrl+C to stop.")
+        key_queue = _start_key_listener(stop_event)
+        last_ambient = 0.0
+        last_good = 0.0
+        last_bad = 0.0
+        last_move = 0.0
+        last_speech = 0.0
+        while not stop_event.is_set():
+            try:
+                cmd = key_queue.get_nowait()
+            except queue.Empty:
+                cmd = None
+            if cmd == "1":
+                phone_present = True
+                print("[state] PHONE PRESENT")
+                if time.time() - last_move >= self.config.min_gap_seconds:
+                    self._play_next(good_job, "good_job", speaker, good_quips)
+                    last_move = time.time()
+                    last_good = last_move
+                if speaker and time.time() - last_speech >= self.config.min_gap_seconds:
+                    speaker.say(random.choice(placed_quips))
+                    last_speech = time.time()
+            elif cmd == "2":
+                phone_present = False
+                print("[state] PHONE ABSENT")
+                if time.time() - last_move >= self.config.min_gap_seconds:
+                    self._play_next(bad, "bad", speaker, bad_quips)
+                    last_move = time.time()
+                    last_bad = last_move
+                if speaker and time.time() - last_speech >= self.config.min_gap_seconds:
+                    speaker.say(random.choice(taken_quips))
+                    last_speech = time.time()
+            elif cmd is not None:
+                print("Use 1 (present) or 2 (absent).")
+            now = time.time()
+            if phone_present:
+                if (
+                    now - last_good >= self.config.good_job_interval
+                    and now - last_move >= self.config.min_gap_seconds
+                ):
+                    self._play_next(good_job, "good_job", speaker, good_quips)
+                    last_good = time.time()
+                    last_move = last_good
+                elif (
+                    now - last_ambient >= self.config.ambient_interval
+                    and now - last_move >= self.config.min_gap_seconds
+                ):
+                    self._play_next(ambient, "ambient")
+                    last_ambient = time.time()
+                    last_move = last_ambient
+            else:
+                if (
+                    now - last_bad >= self.config.bad_interval
+                    and now - last_move >= self.config.min_gap_seconds
+                ):
+                    self._play_next(bad, "bad", speaker, bad_quips)
+                    last_bad = time.time()
+                    last_move = last_bad
+            time.sleep(0.1)
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
+        moves = SituationMovements(reachy_mini)
+        ambient_cycle = self._cycle_movements(moves.ambient())
+        good_cycle = self._cycle_movements(moves.good_job())
+        bad_cycle = self._cycle_movements(moves.bad())
+        placed_quips = [
+            "Nice. Phone is parked. Let's focus.",
+            "Great. Phone down. You've got this.",
+            "All set. Phone is home.",
+            "Perfect. Phone secured.",
+        ]
+        taken_quips = [
+            "Hey, the phone left its spot.",
+            "Phone's gone. Want to put it back?",
+            "Uh oh. Phone off the desk.",
+            "Phone is away. Let's bring it back.",
+        ]
+        good_quips = [
+            "Nice work keeping the phone in place.",
+            "Focus mode: still on.",
+            "Great job staying on track.",
+        ]
+        bad_quips = [
+            "The phone's tempting you again.",
+            "Let's put it back and refocus.",
+            "Phone away, focus goes stronger.",
+        ]
+        speaker = None
+        if self.enable_tts and not stop_event.is_set():
+            try:
+                speaker = ElevenLabsSpeaker(
+                    reachy=reachy_mini,
+                    voice_id=self.voice_id,
+                    model_id=self.model_id,
+                    output_format=self.output_format,
+                    cache_dir=self.cache_dir,
+                )
+            except Exception:
+                speaker = None
+        print("Starting Reachy Phone Home (manual state simulation).")
+        self._run_state_loop(
+            stop_event=stop_event,
+            ambient=ambient_cycle,
+            good_job=good_cycle,
+            bad=bad_cycle,
+            speaker=speaker,
+            placed_quips=placed_quips,
+            taken_quips=taken_quips,
+            good_quips=good_quips,
+            bad_quips=bad_quips,
+        )
+if __name__ == "__main__":
+    # You can run the app directly from this script
+    parser = argparse.ArgumentParser(description="Reachy Phone Home app (simulated)")
+    parser.add_argument("--ambient-interval", type=float, default=5.0)
+    parser.add_argument("--good-job-interval", type=float, default=10.0)
+    parser.add_argument("--bad-interval", type=float, default=5.0)
+    parser.add_argument("--min-gap", type=float, default=5.0)
+    parser.add_argument("--no-media", action="store_true", help="Disable media backend")
+    parser.add_argument("--tts", action="store_true", help="Enable TTS")
+    parser.add_argument("--voice-id", type=str, default="KiWrnassWh6wLlOzZhGd")
+    parser.add_argument("--model-id", type=str, default="eleven_multilingual_v2")
+    parser.add_argument("--output-format", type=str, default="pcm_22050")
+    parser.add_argument(
+        "--cache-dir",
+        type=str,
+        default=str(Path(__file__).resolve().parent / "assets" / "quips"),
+        help="Directory to cache ElevenLabs quips",
+    )
+    parser.add_argument(
+        "--prewarm-quips",
+        action="store_true",
+        help="Download and cache all quips, then exit",
+    )
+    args = parser.parse_args()
+    config = SimulationConfig(
+        ambient_interval=args.ambient_interval,
+        good_job_interval=args.good_job_interval,
+        bad_interval=args.bad_interval,
+        min_gap_seconds=args.min_gap,
+    )
+    with ReachyMini(media_backend="no_media" if args.no_media else "default") as mini:
+        app = ReachyPhoneHome(config=config)
+        app.enable_tts = args.tts and not args.no_media
+        app.voice_id = args.voice_id
+        app.model_id = args.model_id
+        app.output_format = args.output_format
+        app.cache_dir = Path(args.cache_dir)
+        if args.prewarm_quips:
+            app.enable_tts = True
+            speaker = ElevenLabsSpeaker(
+                reachy=mini,
+                voice_id=app.voice_id,
+                model_id=app.model_id,
+                output_format=app.output_format,
+                cache_dir=app.cache_dir,
+            )
+            all_quips = [
+                "Nice. Phone is parked. Let's focus.",
+                "Great. Phone down. You've got this.",
+                "All set. Phone is home.",
+                "Perfect. Phone secured.",
+                "Hey, the phone left its spot.",
+                "Phone's gone. Want to put it back?",
+                "Uh oh. Phone off the desk.",
+                "Phone is away. Let's bring it back.",
+                "Nice work keeping the phone in place.",
+                "Focus mode: still on.",
+                "Great job staying on track.",
+                "The phone's tempting you again.",
+                "Let's put it back and refocus.",
+                "Phone away, focus goes stronger.",
+            ]
+            for quip in all_quips:
+                speaker.say(quip)
+            print(f"Cached {len(all_quips)} quips in {app.cache_dir}")
+            sys.exit(0)
+        stop = threading.Event()
+        try:
+            print("Running 'reachy_phone_home' a ReachyMiniApp...")
+            print("Press Ctrl+C to stop the app.")
+            app.run(mini, stop)
+            print("App has stopped.")
+        except KeyboardInterrupt:
+            print("Stopping the app...")
+            stop.set()

reachy_phone_home_app.py ADDED Viewed

	@@ -0,0 +1,456 @@

+"""Reachy phone tracking + phone-use detection using YOLO26l (no look-down logic)."""
+from __future__ import annotations
+import argparse
+import logging
+import math
+import os
+import time
+from pathlib import Path
+import cv2
+from ultralytics import YOLO
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+try:
+    from reachy_phone_home.movements import MovementScheduler, SituationMovements
+except ModuleNotFoundError:
+    from pathlib import Path
+    import sys
+    repo_root = Path(__file__).resolve().parents[1]
+    sys.path.insert(0, str(repo_root))
+    from reachy_phone_home.movements import MovementScheduler, SituationMovements
+PHONE_CLASS_ID = 67  # COCO "cell phone"
+PERSON_CLASS_ID = 0
+class PhoneFollower:
+    def __init__(self, move_threshold_px: int = 60, head_duration: float = 0.6) -> None:
+        self.move_threshold_px = int(move_threshold_px)
+        self.head_duration = float(head_duration)
+        self.last_x = None
+        self.last_y = None
+    def update_box(self, reachy: ReachyMini, box, y_ratio: float = 0.5) -> None:
+        x1, y1, x2, y2 = _box_xyxy(box)
+        cx = int((x1 + x2) / 2)
+        cy = int(y1 + (y2 - y1) * y_ratio)
+        self.update_xy(reachy, cx, cy)
+    def update_xy(self, reachy: ReachyMini, cx: int, cy: int) -> None:
+        if self.last_x is not None and self.last_y is not None:
+            if (
+                abs(cx - self.last_x) < self.move_threshold_px
+                and abs(cy - self.last_y) < self.move_threshold_px
+            ):
+                return
+        reachy.look_at_image(cx, cy, duration=self.head_duration, perform_movement=True)
+        self.last_x = cx
+        self.last_y = cy
+def _box_xyxy(box) -> tuple[int, int, int, int]:
+    xyxy = box.xyxy[0].tolist()
+    return int(xyxy[0]), int(xyxy[1]), int(xyxy[2]), int(xyxy[3])
+def _overlaps(a: tuple[int, int, int, int], b: tuple[int, int, int, int]) -> bool:
+    ax1, ay1, ax2, ay2 = a
+    bx1, by1, bx2, by2 = b
+    return not (ax2 < bx1 or ax1 > bx2 or ay2 < by1 or ay1 > by2)
+def _pad_box(box: tuple[int, int, int, int], pad_ratio: float) -> tuple[int, int, int, int]:
+    x1, y1, x2, y2 = box
+    bw = max(1, x2 - x1)
+    bh = max(1, y2 - y1)
+    px = int(bw * pad_ratio)
+    py = int(bh * pad_ratio)
+    return x1 - px, y1 - py, x2 + px, y2 + py
+def _clamp_box(
+    box: tuple[int, int, int, int], frame_w: int, frame_h: int
+) -> tuple[int, int, int, int]:
+    x1, y1, x2, y2 = box
+    x1 = max(0, min(frame_w - 1, x1))
+    x2 = max(0, min(frame_w - 1, x2))
+    y1 = max(0, min(frame_h - 1, y1))
+    y2 = max(0, min(frame_h - 1, y2))
+    if x2 < x1:
+        x1, x2 = x2, x1
+    if y2 < y1:
+        y1, y2 = y2, y1
+    return x1, y1, x2, y2
+def _resolve_weights(weights: str, logger: logging.Logger) -> str:
+    if weights in ("yolo26l", "yolo26m", "yolo26s", "yolo26n"):
+        filename = f"{weights}.pt"
+        cache_root = os.getenv("HF_HOME") or str(Path.home() / ".cache" / "reachy_phone_home")
+        cache_dir = Path(cache_root) / "models"
+        cache_path = cache_dir / filename
+        if not cache_path.exists():
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            url = f"https://huggingface.co/Ultralytics/YOLO26/resolve/main/{filename}"
+            logger.info("Downloading %s to %s", url, cache_path)
+            _download_file(url, cache_path)
+        return str(cache_path)
+    return weights
+def _download_file(url: str, dest: Path) -> None:
+    import urllib.request
+    with urllib.request.urlopen(url) as response, open(dest, "wb") as out_file:
+        out_file.write(response.read())
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Reachy phone use tracker (YOLO26l)")
+    parser.add_argument("--weights", type=str, default="yolo26l")
+    parser.add_argument("--conf", type=float, default=0.15)
+    parser.add_argument("--process-every", type=int, default=1)
+    parser.add_argument("--imgsz", type=int, default=640)
+    parser.add_argument("--head-duration", type=float, default=1.2)
+    parser.add_argument("--move-threshold-px", type=int, default=60)
+    parser.add_argument("--no-head", action="store_true")
+    parser.add_argument("--phone-use-confirm-sec", type=float, default=0.5)
+    parser.add_argument("--phone-use-clear-sec", type=float, default=0.5)
+    parser.add_argument("--phone-not-seen-clear-sec", type=float, default=1.0)
+    parser.add_argument("--pad", type=float, default=0.1)
+    parser.add_argument("--missing-neutral-sec", type=float, default=0.5)
+    parser.add_argument("--neutral-duration", type=float, default=1.2)
+    parser.add_argument("--person-y-ratio", type=float, default=0.3)
+    parser.add_argument("--look-down-after-sec", type=float, default=5.0)
+    parser.add_argument("--look-down-duration", type=float, default=1.2)
+    parser.add_argument("--look-down-z-mm", type=float, default=8.0)
+    parser.add_argument("--look-down-pitch-deg", type=float, default=30.0)
+    parser.add_argument("--look-down-window-sec", type=float, default=5.0)
+    parser.add_argument("--person-search-window-sec", type=float, default=5.0)
+    parser.add_argument("--no-antenna", action="store_true")
+    parser.add_argument("--antenna-angry-left", type=float, default=-2.6)
+    parser.add_argument("--antenna-angry-right", type=float, default=2.6)
+    parser.add_argument("--antenna-neutral-left", type=float, default=0.0)
+    parser.add_argument("--antenna-neutral-right", type=float, default=0.0)
+    parser.add_argument("--antenna-transition-sec", type=float, default=0.5)
+    parser.add_argument("--antenna-relax-sec", type=float, default=1.0)
+    parser.add_argument("--antenna-happy-amp", type=float, default=0.2)
+    parser.add_argument("--antenna-happy-duration", type=float, default=0.5)
+    parser.add_argument("--good-job-heartbeats", type=int, default=3)
+    parser.add_argument("--phone-use-bad-sec", type=float, default=10.0)
+    parser.add_argument("--movement-restore-sec", type=float, default=0.6)
+    parser.add_argument("--no-display", action="store_true")
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+    logger = logging.getLogger("yolo26l_phone_use_tracker")
+    weights = _resolve_weights(args.weights, logger)
+    model = YOLO(weights)
+    with ReachyMini() as reachy:
+        follower = PhoneFollower(
+            move_threshold_px=args.move_threshold_px,
+            head_duration=args.head_duration,
+        )
+        movements = SituationMovements(reachy)
+        scheduler = MovementScheduler(
+            movements,
+            good_job_heartbeats=args.good_job_heartbeats,
+            phone_use_bad_sec=args.phone_use_bad_sec,
+            phone_use_clear_sec=args.phone_use_clear_sec,
+            restore_head_duration=args.movement_restore_sec,
+        )
+        if not args.no_display:
+            cv2.namedWindow("YOLO26L Phone Use")
+        last_phone_use = 0.0
+        last_phone_use_state = False
+        phone_use_start = None
+        phone_use_stop = None
+        frame_count = 0
+        last_phone_label = None
+        phone_label_miss = 0
+        last_antenna_mode = "neutral"
+        last_phone_seen = time.time()
+        neutral_active = False
+        look_down_active = False
+        person_track_start = None
+        missing_start = None
+        last_heartbeat = time.time()
+        last_track_state = None
+        oscillate_start = None
+        last_oscillate_update = 0.0
+        look_down_cycles = 0
+        last_prompt = 0.0
+        mode = "tracking_phone"
+        mode_start = time.time()
+        while True:
+            frame = reachy.media.get_frame()
+            if frame is None:
+                continue
+            frame_count += 1
+            if args.process_every > 1 and frame_count % max(1, args.process_every) != 0:
+                if not args.no_display:
+                    cv2.imshow("YOLO26L Phone Use", frame)
+                    if cv2.waitKey(1) & 0xFF == ord("q"):
+                        break
+                continue
+            results = model(
+                frame,
+                verbose=False,
+                classes=[PERSON_CLASS_ID, PHONE_CLASS_ID],
+                conf=args.conf,
+                imgsz=args.imgsz,
+            )
+            boxes = results[0].boxes if results else None
+            person_boxes = []
+            phone_boxes = []
+            if boxes is not None and hasattr(boxes, "cls"):
+                for i in range(len(boxes)):
+                    cls = int(boxes.cls[i].item())
+                    if cls == PERSON_CLASS_ID:
+                        person_boxes.append(boxes[i])
+                    elif cls == PHONE_CLASS_ID:
+                        phone_boxes.append(boxes[i])
+            phone_seen = len(phone_boxes) > 0
+            phone_use = False
+            best_phone = None
+            if person_boxes and phone_boxes:
+                best_person = max(
+                    person_boxes,
+                    key=lambda b: float(b.conf[0].item()) if hasattr(b, "conf") else 0.0,
+                )
+                pxyxy = _pad_box(_box_xyxy(best_person), args.pad)
+                for phbox in phone_boxes:
+                    phxyxy = _pad_box(_box_xyxy(phbox), args.pad)
+                    if _overlaps(pxyxy, phxyxy):
+                        phone_use = True
+                        break
+            if phone_boxes:
+                best_phone = max(
+                    phone_boxes,
+                    key=lambda b: float(b.conf[0].item()) if hasattr(b, "conf") else 0.0,
+                )
+                if not args.no_head:
+                    follower.update_box(reachy, best_phone, y_ratio=0.5)
+                last_phone_seen = time.time()
+                neutral_active = False
+                look_down_active = False
+                person_track_start = None
+                missing_start = None
+                look_down_cycles = 0
+                last_prompt = 0.0
+                mode = "tracking_phone"
+                mode_start = time.time()
+            if not phone_seen and time.time() - last_phone_seen >= args.missing_neutral_sec:
+                if missing_start is None:
+                    missing_start = time.time()
+                if not neutral_active:
+                    reachy.goto_target(head=create_head_pose(), duration=args.neutral_duration)
+                    neutral_active = True
+                if mode == "tracking_phone":
+                    mode = "tracking_person"
+                    mode_start = time.time()
+                    look_down_active = False
+                if mode == "tracking_person":
+                    if person_boxes and not args.no_head:
+                        best_person = max(
+                            person_boxes,
+                            key=lambda b: float(b.conf[0].item()) if hasattr(b, "conf") else 0.0,
+                        )
+                        follower.update_box(reachy, best_person, y_ratio=args.person_y_ratio)
+                    if time.time() - mode_start >= args.person_search_window_sec:
+                        mode = "looking_down"
+                        mode_start = time.time()
+                        look_down_active = False
+                if mode == "looking_down":
+                    if not look_down_active:
+                        reachy.goto_target(
+                            head=create_head_pose(
+                                z=args.look_down_z_mm,
+                                pitch=args.look_down_pitch_deg,
+                                mm=True,
+                                degrees=True,
+                            ),
+                            duration=args.look_down_duration,
+                        )
+                        look_down_active = True
+                        look_down_cycles += 1
+                        if look_down_cycles >= 2 and time.time() - last_prompt >= 10.0:
+                            logger.info("Can you please put the phone in front of me?")
+                            last_prompt = time.time()
+                    if time.time() - mode_start >= args.look_down_window_sec:
+                        mode = "tracking_person"
+                        mode_start = time.time()
+            if phone_seen:
+                track_state = "tracking_phone"
+            elif mode == "looking_down":
+                track_state = "looking_down"
+            elif mode == "tracking_person":
+                track_state = "tracking_person"
+            else:
+                track_state = "searching_phone"
+            if track_state != last_track_state:
+                logger.info("[state] %s", track_state)
+                last_track_state = track_state
+            if phone_use:
+                last_phone_use = time.time()
+                phone_use_stop = None
+                if phone_use_start is None:
+                    phone_use_start = time.time()
+                if not last_phone_use_state and time.time() - phone_use_start >= args.phone_use_confirm_sec:
+                    logger.info("[state] phone use detected")
+                    last_phone_use_state = True
+            else:
+                phone_use_start = None
+                if phone_seen:
+                    if phone_use_stop is None:
+                        phone_use_stop = time.time()
+                    if last_phone_use_state and time.time() - phone_use_stop >= args.phone_use_clear_sec:
+                        logger.info("[state] phone use stopped")
+                        last_phone_use_state = False
+                else:
+                    phone_use_stop = None
+                    if last_phone_use_state and time.time() - last_phone_use >= args.phone_not_seen_clear_sec:
+                        logger.info("[state] phone use stopped")
+                        last_phone_use_state = False
+            if time.time() - last_heartbeat >= 10.0:
+                logger.info("[heartbeat] phone_detected=%s", "yes" if phone_seen else "no")
+                if (
+                    not args.no_antenna
+                    and not last_phone_use_state
+                    and last_track_state == "tracking_phone"
+                    and phone_seen
+                ):
+                    oscillate_start = time.time()
+                last_heartbeat = time.time()
+                scheduler.on_heartbeat(
+                    phone_tracked=(last_track_state == "tracking_phone"),
+                    phone_use=last_phone_use_state,
+                )
+            if not args.no_antenna:
+                if last_phone_use_state:
+                    antenna_mode = "angry"
+                elif phone_seen:
+                    antenna_mode = "tracking"
+                else:
+                    antenna_mode = "neutral"
+                if antenna_mode != last_antenna_mode:
+                    if antenna_mode == "angry":
+                        reachy.goto_target(
+                            antennas=[args.antenna_angry_left, args.antenna_angry_right],
+                            duration=args.antenna_transition_sec,
+                        )
+                    else:
+                        duration = (
+                            args.antenna_relax_sec
+                            if last_antenna_mode == "angry"
+                            else args.antenna_transition_sec
+                        )
+                        reachy.goto_target(
+                            antennas=[args.antenna_neutral_left, args.antenna_neutral_right],
+                            duration=duration,
+                        )
+                    last_antenna_mode = antenna_mode
+                if oscillate_start is not None and antenna_mode == "tracking":
+                    elapsed = time.time() - oscillate_start
+                    if elapsed <= args.antenna_happy_duration:
+                        now = time.time()
+                        if now - last_oscillate_update >= 0.05:
+                            t = elapsed / args.antenna_happy_duration
+                            val = args.antenna_happy_amp * math.sin(-math.pi / 2 + math.pi * t)
+                            reachy.set_target(antennas=(val, -val))
+                            last_oscillate_update = now
+                    else:
+                        oscillate_start = None
+            if not args.no_display:
+                display = frame.copy()
+                frame_h, frame_w = display.shape[:2]
+                if person_boxes:
+                    best_person = max(
+                        person_boxes,
+                        key=lambda b: float(b.conf[0].item()) if hasattr(b, "conf") else 0.0,
+                    )
+                    x1, y1, x2, y2 = _clamp_box(
+                        _pad_box(_box_xyxy(best_person), args.pad), frame_w, frame_h
+                    )
+                    cv2.rectangle(display, (x1, y1), (x2, y2), (0, 165, 255), 2)
+                    if hasattr(best_person, "conf"):
+                        conf = float(best_person.conf[0].item())
+                        cv2.putText(
+                            display,
+                            f"{conf:.2f}",
+                            (x1, max(20, y1 - 6)),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            0.5,
+                            (0, 165, 255),
+                            2,
+                        )
+                if best_phone is not None:
+                    x1, y1, x2, y2 = _clamp_box(
+                        _pad_box(_box_xyxy(best_phone), args.pad), frame_w, frame_h
+                    )
+                    cv2.rectangle(display, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                    conf = float(best_phone.conf[0].item()) if hasattr(best_phone, "conf") else None
+                    label = f"phone {conf:.2f}" if conf is not None else "phone"
+                    last_phone_label = (x1, y1, label)
+                    phone_label_miss = 0
+                else:
+                    phone_label_miss += 1
+                    if phone_label_miss >= 5:
+                        last_phone_label = None
+                if last_phone_label is not None:
+                    x1, y1, label = last_phone_label
+                    cv2.putText(
+                        display,
+                        label,
+                        (x1, max(20, y1 - 6)),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        0.6,
+                        (0, 255, 0),
+                        2,
+                        cv2.LINE_AA,
+                    )
+                if last_phone_use_state:
+                    cv2.rectangle(display, (5, 5), (230, 55), (0, 0, 255), -1)
+                    cv2.putText(
+                        display,
+                        "PHONE USE",
+                        (12, 42),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        1.2,
+                        (255, 255, 255),
+                        3,
+                    )
+                cv2.imshow("YOLO26L Phone Use", display)
+                if cv2.waitKey(1) & 0xFF == ord("q"):
+                    break
+        if not args.no_display:
+            cv2.destroyAllWindows()
+if __name__ == "__main__":
+    main()

setup.cfg ADDED Viewed

	@@ -0,0 +1,12 @@

+[metadata]
+name = reachy_phone_home
+version = 0.1.0
+description = Phone focus companion for Reachy Mini
+[options]
+packages = find:
+python_requires = >=3.10
+[options.entry_points]
+reachy_mini_apps =
+    reachy_phone_home = reachy_phone_home.main:ReachyPhoneHome

setup.py ADDED Viewed

	@@ -0,0 +1,3 @@


1	+ from distutils.core import setup
2	+
3	+ setup()

style.css ADDED Viewed

	@@ -0,0 +1,98 @@

+:root {
+  --bg: #f7f4ed;
+  --ink: #1f1d1a;
+  --muted: #5e5a52;
+  --accent: #ffcc4d;
+  --card: #ffffff;
+}
+* {
+  box-sizing: border-box;
+}
+body {
+  margin: 0;
+  font-family: "IBM Plex Sans", "SF Pro Text", "Helvetica Neue", Arial, sans-serif;
+  background: radial-gradient(circle at top, #fff5d6, var(--bg) 45%, #eef0f2 100%);
+  color: var(--ink);
+}
+.page {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 48px 24px 72px;
+}
+.hero {
+  background: var(--card);
+  border-radius: 20px;
+  padding: 32px;
+  box-shadow: 0 18px 40px rgba(31, 29, 26, 0.08);
+}
+.badge {
+  display: inline-block;
+  padding: 6px 12px;
+  border-radius: 999px;
+  background: var(--accent);
+  font-weight: 600;
+  font-size: 12px;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.hero h1 {
+  margin: 16px 0 12px;
+  font-size: 40px;
+  letter-spacing: -0.02em;
+}
+.hero p {
+  margin: 0;
+  color: var(--muted);
+  font-size: 18px;
+  line-height: 1.6;
+}
+.cta {
+  margin-top: 24px;
+  padding: 14px 18px;
+  background: #fff2c2;
+  border-radius: 12px;
+  font-size: 14px;
+  display: inline-flex;
+  gap: 8px;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.cta code {
+  background: #fff;
+  padding: 6px 10px;
+  border-radius: 8px;
+  font-size: 13px;
+}
+.grid {
+  margin-top: 28px;
+  display: grid;
+  gap: 18px;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}
+.card {
+  background: var(--card);
+  border-radius: 16px;
+  padding: 20px;
+  box-shadow: 0 10px 24px rgba(31, 29, 26, 0.06);
+}
+.card h2 {
+  margin-top: 0;
+  font-size: 18px;
+}
+.card p {
+  margin-bottom: 0;
+  color: var(--muted);
+}