Spaces:

robertkeus
/

reachys-brain

Running

App Files Files Community

robertkeus commited on Dec 31, 2025

Commit

57ba3ed

verified ·

1 Parent(s): c10255d

Add comprehensive feature documentation page

Browse files

Files changed (17) hide show

features.html +571 -0
index.html +5 -2
reachy_ios_bridge/__pycache__/audio_playback.cpython-312.pyc +0 -0
reachy_ios_bridge/__pycache__/server.cpython-312.pyc +0 -0
reachy_ios_bridge/audio_playback.py +104 -15
reachy_ios_bridge/idle_movement_service.py +447 -0
reachy_ios_bridge/routes/__pycache__/voice.cpython-312.pyc +0 -0
reachy_ios_bridge/routes/conversation.py +7 -0
reachy_ios_bridge/routes/conversation_services.py +6 -0
reachy_ios_bridge/routes/games/__pycache__/tamareachy.cpython-312.pyc +0 -0
reachy_ios_bridge/routes/games/__pycache__/tamareachy_monitor.cpython-312.pyc +0 -0
reachy_ios_bridge/routes/games/tamareachy.py +19 -0
reachy_ios_bridge/routes/games/tamareachy_monitor.py +166 -0
reachy_ios_bridge/routes/user_settings.py +83 -0
reachy_ios_bridge/routes/voice.py +118 -12
reachy_ios_bridge/server.py +156 -1
style.css +201 -0

features.html ADDED Viewed

	@@ -0,0 +1,571 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Features - Reachy's Brain</title>
+    <link rel="stylesheet" href="style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Mulish:wght@400;500;600;700;800&family=Nunito:wght@400;500;600;700&display=swap" rel="stylesheet">
+</head>
+<body>
+    <div class="page-wrapper">
+        <!-- Navigation -->
+        <nav class="nav">
+            <div class="nav-brand">
+                <a href="index.html" style="display: flex; align-items: center; gap: 0.75rem; text-decoration: none;">
+                    <img src="logo.png" alt="Reachy's Brain" class="nav-logo-img">
+                    <span class="nav-title">Reachy's Brain</span>
+                </a>
+            </div>
+            <div class="nav-links">
+                <a href="index.html">Home</a>
+                <a href="index.html#examples">Examples</a>
+                <a href="index.html#getting-started">Setup</a>
+            </div>
+        </nav>
+        <!-- Features Documentation -->
+        <section class="section docs-page">
+            <div class="docs-header">
+                <h1>Complete Feature Guide</h1>
+                <p>Everything Reachy's Brain can do for you</p>
+            </div>
+            <!-- Voice & Communication -->
+            <div class="docs-category">
+                <h2>🗣️ Voice & Communication</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🗣️</span>
+                        <h3>Voice Conversations</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Have natural, flowing conversations with Reachy using OpenAI's Realtime API. The conversation feels natural with sub-second latency and interruption awareness.</p>
+                        <h4>What you can do:</h4>
+                        <ul>
+                            <li>Ask questions on any topic</li>
+                            <li>Have extended conversations with context memory</li>
+                            <li>Interrupt Reachy mid-sentence naturally</li>
+                            <li>Switch topics seamlessly</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Hey Reachy, tell me a joke"</code>
+                            <code>"What's the meaning of life?"</code>
+                            <code>"Can you explain quantum computing simply?"</code>
+                            <code>"Tell me a story about a robot"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">💬</span>
+                        <h3>Scheduled Messages</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Schedule WhatsApp and iMessage messages to be sent at a specific time. Perfect for birthday wishes, reminders to friends, or any message you want to send later.</p>
+                        <h4>Supported platforms:</h4>
+                        <ul>
+                            <li><strong>WhatsApp</strong> - Schedule messages to any WhatsApp contact</li>
+                            <li><strong>iMessage</strong> - Schedule texts to iPhone contacts</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Send a WhatsApp to Mom tomorrow at 9am saying happy birthday"</code>
+                            <code>"Schedule a message to John on Friday: Don't forget our meeting"</code>
+                            <code>"Text Sarah at 6pm: I'm on my way home"</code>
+                            <code>"Send a WhatsApp to the team at 10am: Meeting starts in 30 minutes"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">👥</span>
+                        <h3>iOS Contacts</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Access your iPhone contacts through voice commands. Quickly find phone numbers, email addresses, and other contact details without picking up your phone.</p>
+                        <h4>What you can access:</h4>
+                        <ul>
+                            <li>Phone numbers</li>
+                            <li>Email addresses</li>
+                            <li>Physical addresses</li>
+                            <li>Contact notes</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"What's John's phone number?"</code>
+                            <code>"Find Sarah's email address"</code>
+                            <code>"Show me the contact details for my dentist"</code>
+                            <code>"What's the address for ABC Company?"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Information & Search -->
+            <div class="docs-category">
+                <h2>🔍 Information & Search</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🌤️</span>
+                        <h3>Weather</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Get current weather conditions and forecasts for any location worldwide. Reachy can tell you about temperature, conditions, humidity, and upcoming weather.</p>
+                        <h4>Information available:</h4>
+                        <ul>
+                            <li>Current temperature and conditions</li>
+                            <li>Weather forecasts</li>
+                            <li>Humidity and wind information</li>
+                            <li>Sunrise and sunset times</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"What's the weather like today?"</code>
+                            <code>"Will it rain in Amsterdam tomorrow?"</code>
+                            <code>"What's the temperature in Tokyo?"</code>
+                            <code>"Do I need an umbrella this week?"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">📰</span>
+                        <h3>News</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Stay informed with the latest news headlines and stories. Reachy can fetch news from various categories and give you summaries.</p>
+                        <h4>News categories:</h4>
+                        <ul>
+                            <li>Top headlines</li>
+                            <li>Technology news</li>
+                            <li>Sports updates</li>
+                            <li>Business & finance</li>
+                            <li>Entertainment</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"What's in the news today?"</code>
+                            <code>"Tell me about the latest tech news"</code>
+                            <code>"Any sports news?"</code>
+                            <code>"What's happening in the stock market?"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🔍</span>
+                        <h3>Web Search</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Search the web for information, facts, and answers. Reachy uses web search to find up-to-date information on any topic.</p>
+                        <h4>Use cases:</h4>
+                        <ul>
+                            <li>Fact-checking and research</li>
+                            <li>Finding local businesses</li>
+                            <li>Looking up current events</li>
+                            <li>Getting how-to information</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Search for the best Italian restaurants nearby"</code>
+                            <code>"Who won the World Cup in 2022?"</code>
+                            <code>"How tall is the Eiffel Tower?"</code>
+                            <code>"What are the opening hours of the local library?"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">📍</span>
+                        <h3>Location</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Get your current location and find nearby places. Ask about distances, directions, and points of interest around you.</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Current location detection</li>
+                            <li>Nearby place search</li>
+                            <li>Distance calculations</li>
+                            <li>Points of interest</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Where am I right now?"</code>
+                            <code>"Find coffee shops nearby"</code>
+                            <code>"How far is the nearest train station?"</code>
+                            <code>"What restaurants are within walking distance?"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🕐</span>
+                        <h3>Date & Time</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Get current time, dates, and time zone information. Useful for scheduling, international calls, or just checking the time hands-free.</p>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"What time is it?"</code>
+                            <code>"What's the date today?"</code>
+                            <code>"What time is it in New York?"</code>
+                            <code>"How many days until Christmas?"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Vision & Camera -->
+            <div class="docs-category">
+                <h2>📷 Vision & Camera</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">📷</span>
+                        <h3>Vision</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Reachy can see and describe what's in front of it using the built-in camera. This enables visual understanding, object recognition, and scene description.</p>
+                        <h4>Capabilities:</h4>
+                        <ul>
+                            <li>Describe scenes and surroundings</li>
+                            <li>Identify objects and people</li>
+                            <li>Read text from documents or screens</li>
+                            <li>Analyze images and photos</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"What do you see?"</code>
+                            <code>"Describe what's on my desk"</code>
+                            <code>"Can you read what's on this paper?"</code>
+                            <code>"How many people are in the room?"</code>
+                            <code>"What color is my shirt?"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Productivity -->
+            <div class="docs-category">
+                <h2>📝 Productivity</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">⏰</span>
+                        <h3>iOS Reminders</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Create and manage reminders directly on your iPhone through voice commands. Never forget important tasks, appointments, or to-dos.</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Create time-based reminders</li>
+                            <li>Set recurring reminders</li>
+                            <li>Add reminders to specific lists</li>
+                            <li>Check existing reminders</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Remind me to call mom at 5pm"</code>
+                            <code>"Add a reminder to buy groceries tomorrow"</code>
+                            <code>"Set a reminder for my dentist appointment on Friday"</code>
+                            <code>"Remind me every Monday to submit my timesheet"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">📝</span>
+                        <h3>Notes</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Quickly capture thoughts and ideas through voice. Dictate notes to Reachy and save them for later reference.</p>
+                        <h4>Use cases:</h4>
+                        <ul>
+                            <li>Quick thought capture</li>
+                            <li>Shopping lists</li>
+                            <li>Ideas and brainstorming</li>
+                            <li>Personal memos</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Take a note: remember to update the project timeline"</code>
+                            <code>"Save this idea: new feature for the app"</code>
+                            <code>"Note to self: research machine learning frameworks"</code>
+                            <code>"Add to my shopping list: milk, eggs, bread"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🎙️</span>
+                        <h3>Meeting Notes</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Automatic meeting transcription and summarization. Reachy listens to your meetings, captures key points, and generates summaries with action items.</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Real-time transcription</li>
+                            <li>Automatic summarization</li>
+                            <li>Action item extraction</li>
+                            <li>Key decision tracking</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Start taking meeting notes"</code>
+                            <code>"Summarize our discussion"</code>
+                            <code>"What were the action items from this meeting?"</code>
+                            <code>"Stop recording the meeting"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Games & Entertainment -->
+            <div class="docs-category">
+                <h2>🎮 Games & Entertainment</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">♟️</span>
+                        <h3>Play Chess</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Challenge Reachy to a game of chess! Play using voice commands and watch Reachy react to your moves with expressive animations.</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Full chess game with standard rules</li>
+                            <li>Voice-controlled moves</li>
+                            <li>Multiple difficulty levels</li>
+                            <li>Move suggestions and analysis</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Let's play chess"</code>
+                            <code>"Move pawn to e4"</code>
+                            <code>"Castle kingside"</code>
+                            <code>"What's your next move?"</code>
+                            <code>"Show me the board"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🃏</span>
+                        <h3>Memory Game</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Test your memory with interactive card matching games. Reachy keeps track of the game state and celebrates your wins!</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Classic card matching gameplay</li>
+                            <li>Multiple difficulty levels</li>
+                            <li>Score tracking</li>
+                            <li>Celebratory animations on wins</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Let's play a memory game"</code>
+                            <code>"Flip card number 3"</code>
+                            <code>"How many matches do I have?"</code>
+                            <code>"Start a new game"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🥚</span>
+                        <h3>Tamareachy</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Virtual pet mode! Take care of Reachy like a Tamagotchi. Feed it, play with it, keep it hydrated, and watch its mood change based on how well you care for it.</p>
+                        <h4>Stats to manage:</h4>
+                        <ul>
+                            <li><strong>Hunger</strong> - Feed Reachy regularly</li>
+                            <li><strong>Thirst</strong> - Give water to stay hydrated</li>
+                            <li><strong>Happiness</strong> - Play and interact to keep happy</li>
+                            <li><strong>Energy</strong> - Let Reachy rest when tired</li>
+                            <li><strong>Boredom</strong> - Entertain with games and conversation</li>
+                            <li><strong>Health</strong> - Overall wellbeing</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Feed Reachy"</code>
+                            <code>"How is Reachy feeling?"</code>
+                            <code>"Play with Reachy"</code>
+                            <code>"Give Reachy some water"</code>
+                            <code>"Let Reachy sleep"</code>
+                            <code>"Check Reachy's stats"</code>
+                        </div>
+                        <p class="docs-note">💡 When stats get low, Reachy will proactively ask for help!</p>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🎭</span>
+                        <h3>Animations</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Trigger expressive head movements, gestures, and emotional expressions. Make Reachy come alive with personality!</p>
+                        <h4>Animation types:</h4>
+                        <ul>
+                            <li>Emotional expressions (happy, sad, surprised, thinking)</li>
+                            <li>Head movements (nod, shake, tilt)</li>
+                            <li>Dances and celebrations</li>
+                            <li>Custom recorded animations</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Nod your head"</code>
+                            <code>"Do a happy dance"</code>
+                            <code>"Look surprised"</code>
+                            <code>"Show me you're thinking"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Creation & Development -->
+            <div class="docs-category">
+                <h2>🛠️ Creation & Development</h2>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🎯</span>
+                        <h3>Create Apps</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Build custom apps for Reachy using natural language. Describe what you want and watch it come to life. No coding required!</p>
+                        <h4>What you can create:</h4>
+                        <ul>
+                            <li>Custom conversation personalities</li>
+                            <li>Interactive games</li>
+                            <li>Utility apps</li>
+                            <li>Entertainment experiences</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Create an app that tells dad jokes"</code>
+                            <code>"Make a meditation timer app"</code>
+                            <code>"Build a trivia game about science"</code>
+                            <code>"Create a daily affirmation app"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🌐</span>
+                        <h3>Vibe Coding</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Generate websites and web apps through conversation. Describe your vision and Reachy builds it for you with HTML, CSS, and JavaScript.</p>
+                        <h4>What you can create:</h4>
+                        <ul>
+                            <li>Personal websites and portfolios</li>
+                            <li>Landing pages</li>
+                            <li>Simple web applications</li>
+                            <li>Interactive demos</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Create a portfolio website for me"</code>
+                            <code>"Build a simple todo list app"</code>
+                            <code>"Make a landing page for my startup"</code>
+                            <code>"Create a recipe collection website"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🎬</span>
+                        <h3>Animation Recording</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Record custom animations by physically moving Reachy's head. Save your creations and replay them anytime.</p>
+                        <h4>Features:</h4>
+                        <ul>
+                            <li>Record head movements in real-time</li>
+                            <li>Save with custom names</li>
+                            <li>Replay recorded animations</li>
+                            <li>Share with others</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Start recording an animation"</code>
+                            <code>"Save this animation as 'greeting'"</code>
+                            <code>"Play my custom animation"</code>
+                            <code>"List my recorded animations"</code>
+                        </div>
+                    </div>
+                </div>
+                <div class="docs-feature">
+                    <div class="docs-feature-header">
+                        <span class="docs-icon">🎭</span>
+                        <h3>Custom Personalities</h3>
+                    </div>
+                    <div class="docs-feature-content">
+                        <p>Create unique AI personalities with different voices, behaviors, and conversation styles. Make Reachy truly your own.</p>
+                        <h4>Customizable aspects:</h4>
+                        <ul>
+                            <li>Voice selection (8 OpenAI voices)</li>
+                            <li>Personality traits</li>
+                            <li>Speaking style</li>
+                            <li>Knowledge focus areas</li>
+                        </ul>
+                        <h4>Example commands:</h4>
+                        <div class="docs-examples">
+                            <code>"Create a personality that speaks like a pirate"</code>
+                            <code>"Make Reachy more formal"</code>
+                            <code>"Switch to the Coral voice"</code>
+                            <code>"Create a science teacher personality"</code>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <!-- Back to Home -->
+            <div class="docs-footer-nav">
+                <a href="index.html" class="btn btn-primary">← Back to Home</a>
+                <a href="index.html#getting-started" class="btn btn-secondary">Get Started</a>
+            </div>
+        </section>
+        <!-- Footer -->
+        <footer class="footer">
+            <div class="footer-content">
+                <div class="footer-brand">
+                    <img src="logo.png" alt="Reachy's Brain" class="footer-logo-img">
+                    <span>Reachy's Brain</span>
+                </div>
+                <div class="footer-links">
+                    <a href="index.html">Home</a>
+                    <a href="features.html">All Features</a>
+                    <a href="privacy.html">Privacy Policy</a>
+                    <a href="terms.html">Terms of Service</a>
+                </div>
+                <p class="footer-copyright">MIT License</p>
+            </div>
+        </footer>
+    </div>
+</body>
+</html>

index.html CHANGED Viewed

@@ -19,7 +19,7 @@
             </div>
             <div class="nav-links">
                 <a href="#features">Features</a>
-                <a href="#examples">Examples</a>
                 <a href="#getting-started">Setup</a>
                 <a href="#api">Bridge API</a>
             </div>
@@ -155,6 +155,9 @@
                     <p>Your API keys stay on Reachy. All processing happens on the robot itself.</p>
                 </div>
             </div>
         </section>
         <!-- Feature Examples Section -->
@@ -824,7 +827,7 @@
                     <span>Reachy's Brain</span>
                 </div>
                 <div class="footer-links">
-                    <a href="https://huggingface.co/spaces/robertkeus/reachys-brain/blob/main/README.md">Documentation</a>
                     <a href="https://github.com/robertkeus/reachy-ios-bridge">GitHub</a>
                     <a href="privacy.html">Privacy Policy</a>
                     <a href="terms.html">Terms of Service</a>

             </div>
             <div class="nav-links">
                 <a href="#features">Features</a>
+                <a href="features.html">Full Guide</a>
                 <a href="#getting-started">Setup</a>
                 <a href="#api">Bridge API</a>
             </div>
                     <p>Your API keys stay on Reachy. All processing happens on the robot itself.</p>
                 </div>
             </div>
+            <div class="section-cta">
+                <a href="features.html" class="btn btn-secondary">📖 View Complete Feature Guide</a>
+            </div>
         </section>
         <!-- Feature Examples Section -->
                     <span>Reachy's Brain</span>
                 </div>
                 <div class="footer-links">
+                    <a href="features.html">Feature Guide</a>
                     <a href="https://github.com/robertkeus/reachy-ios-bridge">GitHub</a>
                     <a href="privacy.html">Privacy Policy</a>
                     <a href="terms.html">Terms of Service</a>

reachy_ios_bridge/__pycache__/audio_playback.cpython-312.pyc CHANGED Viewed

Binary files a/reachy_ios_bridge/__pycache__/audio_playback.cpython-312.pyc and b/reachy_ios_bridge/__pycache__/audio_playback.cpython-312.pyc differ

reachy_ios_bridge/__pycache__/server.cpython-312.pyc CHANGED Viewed

Binary files a/reachy_ios_bridge/__pycache__/server.cpython-312.pyc and b/reachy_ios_bridge/__pycache__/server.cpython-312.pyc differ

reachy_ios_bridge/audio_playback.py CHANGED Viewed

@@ -2,6 +2,7 @@
 import asyncio
 import logging
 import subprocess
 import threading
 from queue import Empty, Queue
@@ -20,6 +21,29 @@ AUDIO_DEVICE = "plug:reachymini_audio_sink"
 # Playback timing
 STOP_DELAY_SECONDS = 0.3  # Delay before stopping to allow buffer to drain
 class AudioPlaybackService:
     """Service for playing PCM16 audio from OpenAI on Reachy's speaker.
@@ -109,9 +133,18 @@ class AudioPlaybackService:
         """Main playback loop running in a separate thread.
         Continuously reads from the queue and writes to aplay.
         """
         try:
-            # Start aplay process
             aplay_cmd = [
                 "aplay",
                 "-r", str(SAMPLE_RATE),
@@ -122,40 +155,96 @@ class AudioPlaybackService:
                 "-q",  # Quiet mode
             ]
-            self._process = subprocess.Popen(
-                aplay_cmd,
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-            )
-            logger.debug(f"Started aplay process: {' '.join(aplay_cmd)}")
             while not self._stop_event.is_set():
                 try:
                     # Get audio from queue with timeout
                     audio_data = self._audio_queue.get(timeout=0.1)
-                    # Write to aplay
-                    if self._process and self._process.stdin:
-                        self._process.stdin.write(audio_data)
-                        self._process.stdin.flush()
                 except Empty:
                     # No audio available, continue waiting
                     continue
                 except BrokenPipeError:
-                    logger.error("aplay pipe broken, restarting...")
                     break
                 except Exception as e:
                     logger.error(f"Error in playback loop: {e}")
                     break
         except Exception as e:
-            logger.error(f"Error starting aplay: {e}")
         finally:
-            # Clean up process
             if self._process:
                 try:
                     if self._process.stdin:

 import asyncio
 import logging
+import shutil
 import subprocess
 import threading
 from queue import Empty, Queue
 # Playback timing
 STOP_DELAY_SECONDS = 0.3  # Delay before stopping to allow buffer to drain
+# Kids mode pitch shift (in cents, 400 = ~1/3 octave higher)
+KIDS_MODE_PITCH_CENTS = 400
+# Global kids mode state
+_kids_mode_enabled = False
+def is_kids_mode_enabled() -> bool:
+    """Check if kids mode (pitch shifting) is enabled."""
+    return _kids_mode_enabled
+def set_kids_mode(enabled: bool) -> None:
+    """Enable or disable kids mode (pitch shifting).
+    Args:
+        enabled: True to enable kids mode, False to disable.
+    """
+    global _kids_mode_enabled
+    _kids_mode_enabled = enabled
+    logger.info(f"🧒 Kids mode {'enabled' if enabled else 'disabled'}")
 class AudioPlaybackService:
     """Service for playing PCM16 audio from OpenAI on Reachy's speaker.
         """Main playback loop running in a separate thread.
         Continuously reads from the queue and writes to aplay.
+        Uses sox for pitch shifting when kids mode is enabled.
         """
+        sox_process: Optional[subprocess.Popen] = None
         try:
+            # Check if kids mode is enabled and sox is available
+            use_pitch_shift = _kids_mode_enabled and shutil.which("sox") is not None
+            if _kids_mode_enabled and not shutil.which("sox"):
+                logger.warning("🧒 Kids mode enabled but sox not found, using normal playback")
+            # aplay command for final output
             aplay_cmd = [
                 "aplay",
                 "-r", str(SAMPLE_RATE),
                 "-q",  # Quiet mode
             ]
+            if use_pitch_shift:
+                # sox command for pitch shifting
+                # Input: raw PCM16 24kHz mono from stdin
+                # Output: raw PCM16 24kHz mono to stdout (piped to aplay)
+                sox_cmd = [
+                    "sox",
+                    "-t", "raw",           # Input format: raw
+                    "-r", str(SAMPLE_RATE),  # Input sample rate
+                    "-e", "signed",        # Input encoding: signed
+                    "-b", "16",            # Input bits: 16
+                    "-c", str(CHANNELS),   # Input channels: mono
+                    "-",                   # Input from stdin
+                    "-t", "raw",           # Output format: raw
+                    "-",                   # Output to stdout
+                    "pitch", str(KIDS_MODE_PITCH_CENTS),  # Pitch shift up
+                ]
+                # Start sox process (reads from stdin, outputs to stdout)
+                sox_process = subprocess.Popen(
+                    sox_cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                # Start aplay process (reads from sox stdout)
+                self._process = subprocess.Popen(
+                    aplay_cmd,
+                    stdin=sox_process.stdout,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                # Close sox stdout in parent so aplay gets EOF when sox closes
+                if sox_process.stdout:
+                    sox_process.stdout.close()
+                logger.info(f"🧒 Started kids mode playback with pitch shift +{KIDS_MODE_PITCH_CENTS} cents")
+            else:
+                # Normal playback without pitch shifting
+                self._process = subprocess.Popen(
+                    aplay_cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                logger.debug(f"Started aplay process: {' '.join(aplay_cmd)}")
+            # Determine which process stdin to write to
+            write_stdin = sox_process.stdin if sox_process else self._process.stdin
             while not self._stop_event.is_set():
                 try:
                     # Get audio from queue with timeout
                     audio_data = self._audio_queue.get(timeout=0.1)
+                    # Write to sox (if pitch shifting) or aplay directly
+                    if write_stdin:
+                        write_stdin.write(audio_data)
+                        write_stdin.flush()
                 except Empty:
                     # No audio available, continue waiting
                     continue
                 except BrokenPipeError:
+                    logger.error("Audio pipe broken, restarting...")
                     break
                 except Exception as e:
                     logger.error(f"Error in playback loop: {e}")
                     break
         except Exception as e:
+            logger.error(f"Error starting audio playback: {e}")
         finally:
+            # Clean up sox process if used
+            if sox_process:
+                try:
+                    if sox_process.stdin:
+                        sox_process.stdin.close()
+                    sox_process.terminate()
+                    sox_process.wait(timeout=1.0)
+                except Exception as e:
+                    logger.error(f"Error cleaning up sox: {e}")
+                    try:
+                        sox_process.kill()
+                    except Exception:
+                        pass
+            # Clean up aplay process
             if self._process:
                 try:
                     if self._process.stdin:

reachy_ios_bridge/idle_movement_service.py ADDED Viewed

	@@ -0,0 +1,447 @@

+"""Idle movement service for subtle, life-like movements when Reachy is inactive.
+Makes smooth, random micro-movements at random intervals to give Reachy
+a more alive, natural presence when not engaged in conversation or animation.
+Includes subtle head movements and antenna twitches.
+"""
+import asyncio
+import logging
+import math
+import random
+import time
+from typing import Optional, Callable
+import httpx
+logger = logging.getLogger(__name__)
+# Movement amplitude settings (in degrees) - very subtle for idle
+IDLE_AMPLITUDE = {
+    "head_roll": 4.0,      # Gentle side tilts
+    "head_pitch": 3.0,     # Slight nods
+    "head_yaw": 6.0,       # Small turns
+    "antenna_left": 15.0,  # Antenna range
+    "antenna_right": 15.0,
+}
+# Timing settings
+IDLE_UPDATE_RATE = 20  # Hz - smooth but not excessive
+IDLE_INTERVAL_RANGE = (5.0, 12.0)  # Seconds between movements - subtle but noticeable
+MOVEMENT_DURATION_RANGE = (1.5, 3.5)  # How long each movement takes
+ANTENNA_TWITCH_CHANCE = 0.3  # Chance of antenna movement with head movement
+# Base position (neutral)
+NEUTRAL_POSITION = {
+    "head_roll": 0.0,
+    "head_pitch": 0.0,
+    "head_yaw": 0.0,
+    "antenna_left": 0.0,
+    "antenna_right": 0.0,
+}
+def _ease_in_out(t: float) -> float:
+    """Smooth easing function for natural movement."""
+    return 0.5 * (1 - math.cos(math.pi * t))
+def _degrees_to_radians(degrees: float) -> float:
+    """Convert degrees to radians."""
+    return degrees * math.pi / 180.0
+class IdleMovement:
+    """Represents a single idle movement to perform."""
+    def __init__(self):
+        """Generate a random idle movement."""
+        # Generate random head position within limits
+        self.head_roll = random.uniform(
+            -IDLE_AMPLITUDE["head_roll"],
+            IDLE_AMPLITUDE["head_roll"]
+        )
+        self.head_pitch = random.uniform(
+            -IDLE_AMPLITUDE["head_pitch"],
+            IDLE_AMPLITUDE["head_pitch"]
+        )
+        self.head_yaw = random.uniform(
+            -IDLE_AMPLITUDE["head_yaw"],
+            IDLE_AMPLITUDE["head_yaw"]
+        )
+        # Sometimes move antennas too
+        if random.random() < ANTENNA_TWITCH_CHANCE:
+            self.antenna_left = random.uniform(
+                -IDLE_AMPLITUDE["antenna_left"],
+                IDLE_AMPLITUDE["antenna_left"]
+            )
+            self.antenna_right = random.uniform(
+                -IDLE_AMPLITUDE["antenna_right"],
+                IDLE_AMPLITUDE["antenna_right"]
+            )
+        else:
+            self.antenna_left = 0.0
+            self.antenna_right = 0.0
+        # Movement duration
+        self.duration = random.uniform(*MOVEMENT_DURATION_RANGE)
+    def to_dict(self) -> dict:
+        """Convert to position dict."""
+        return {
+            "head_roll": self.head_roll,
+            "head_pitch": self.head_pitch,
+            "head_yaw": self.head_yaw,
+            "antenna_left": self.antenna_left,
+            "antenna_right": self.antenna_right,
+        }
+class AntennaOnlyMovement:
+    """Represents an antenna-only twitch movement."""
+    def __init__(self, current_head_pos: dict):
+        """Generate a random antenna movement while keeping head still.
+        Args:
+            current_head_pos: Current head position to maintain.
+        """
+        # Keep head position stable
+        self.head_roll = current_head_pos.get("head_roll", 0.0)
+        self.head_pitch = current_head_pos.get("head_pitch", 0.0)
+        self.head_yaw = current_head_pos.get("head_yaw", 0.0)
+        # Random antenna positions - sometimes asymmetric for personality
+        if random.random() < 0.5:
+            # Symmetric movement
+            angle = random.uniform(-15.0, 15.0)
+            self.antenna_left = angle
+            self.antenna_right = angle
+        else:
+            # Asymmetric - one antenna moves more
+            self.antenna_left = random.uniform(-15.0, 15.0)
+            self.antenna_right = random.uniform(-15.0, 15.0)
+        # Quick antenna movements
+        self.duration = random.uniform(0.5, 1.2)
+    def to_dict(self) -> dict:
+        """Convert to position dict."""
+        return {
+            "head_roll": self.head_roll,
+            "head_pitch": self.head_pitch,
+            "head_yaw": self.head_yaw,
+            "antenna_left": self.antenna_left,
+            "antenna_right": self.antenna_right,
+        }
+class IdleMovementService:
+    """Service for subtle, life-like idle movements.
+    Runs in the background and periodically moves Reachy's head and
+    antennas to give a more alive, natural presence when idle.
+    Automatically pauses when:
+    - Reachy is speaking
+    - An animation is playing
+    - A conversation is active
+    """
+    def __init__(self, daemon_url: str = "http://localhost:8000"):
+        """Initialize the idle movement service.
+        Args:
+            daemon_url: URL of the Reachy daemon API.
+        """
+        self._daemon_url = daemon_url
+        self._is_running = False
+        self._is_paused = False
+        self._idle_task: Optional[asyncio.Task] = None
+        # Current and target positions
+        self._current_pos = NEUTRAL_POSITION.copy()
+        self._target_pos = NEUTRAL_POSITION.copy()
+        self._start_pos = NEUTRAL_POSITION.copy()
+        # Movement timing
+        self._move_start_time = 0.0
+        self._move_duration = 1.0
+        # Activity check callback
+        self._is_busy_callback: Optional[Callable[[], bool]] = None
+        # HTTP client
+        self._client: Optional[httpx.AsyncClient] = None
+        # Error rate limiting
+        self._last_error_time = 0.0
+        logger.info(f"IdleMovementService initialized (daemon: {daemon_url})")
+    def set_busy_callback(self, callback: Callable[[], bool]) -> None:
+        """Set callback to check if robot is busy.
+        Args:
+            callback: Function that returns True if robot is busy.
+        """
+        self._is_busy_callback = callback
+    @property
+    def is_running(self) -> bool:
+        """Check if idle movement service is running."""
+        return self._is_running
+    @property
+    def is_paused(self) -> bool:
+        """Check if idle movements are currently paused."""
+        return self._is_paused
+    def pause(self) -> None:
+        """Pause idle movements (e.g., during conversation)."""
+        if not self._is_paused:
+            self._is_paused = True
+            logger.debug("Idle movements paused")
+    def resume(self) -> None:
+        """Resume idle movements."""
+        if self._is_paused:
+            self._is_paused = False
+            logger.debug("Idle movements resumed")
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create the async HTTP client."""
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self._daemon_url,
+                timeout=2.0,
+            )
+        return self._client
+    async def _goto_pose(
+        self,
+        head_roll: float,
+        head_pitch: float,
+        head_yaw: float,
+        antenna_left: float,
+        antenna_right: float,
+        duration: float,
+    ) -> bool:
+        """Send a goto command to smoothly move to target pose.
+        Args:
+            head_roll: Head tilt in degrees.
+            head_pitch: Head nod in degrees.
+            head_yaw: Head turn in degrees.
+            antenna_left: Left antenna angle in degrees.
+            antenna_right: Right antenna angle in degrees.
+            duration: Movement duration in seconds.
+        Returns:
+            True if successful.
+        """
+        try:
+            client = await self._get_client()
+            payload = {
+                "head_pose": {
+                    "x": 0.0,
+                    "y": 0.0,
+                    "z": 0.0,
+                    "roll": _degrees_to_radians(head_roll),
+                    "pitch": _degrees_to_radians(head_pitch),
+                    "yaw": _degrees_to_radians(head_yaw),
+                },
+                "body_yaw": 0.0,
+                "antennas": [
+                    _degrees_to_radians(antenna_left),
+                    _degrees_to_radians(antenna_right),
+                ],
+                "duration": duration,
+                "interpolation": "minjerk",
+            }
+            response = await client.post(
+                "/api/move/goto",
+                json=payload,
+            )
+            response.raise_for_status()
+            return True
+        except Exception as e:
+            # Rate-limit error logging
+            now = time.time()
+            if now - self._last_error_time > 10.0:
+                logger.warning(f"Idle movement: Failed to goto pose: {e}")
+                self._last_error_time = now
+            return False
+    def _interpolate_position(self) -> dict:
+        """Calculate current interpolated position."""
+        elapsed = time.time() - self._move_start_time
+        t = min(1.0, elapsed / self._move_duration)
+        # Apply easing for smooth movement
+        eased_t = _ease_in_out(t)
+        result = {}
+        for key in NEUTRAL_POSITION.keys():
+            start = self._start_pos.get(key, 0.0)
+            target = self._target_pos.get(key, 0.0)
+            result[key] = start + (target - start) * eased_t
+        return result
+    def _is_movement_complete(self) -> bool:
+        """Check if current movement is complete."""
+        elapsed = time.time() - self._move_start_time
+        return elapsed >= self._move_duration
+    def _start_movement(self, target: dict, duration: float) -> None:
+        """Start a new movement toward target position.
+        Args:
+            target: Target position dict.
+            duration: Movement duration in seconds.
+        """
+        self._start_pos = self._current_pos.copy()
+        self._target_pos = target.copy()
+        self._move_start_time = time.time()
+        self._move_duration = duration
+    def _is_robot_busy(self) -> bool:
+        """Check if robot is currently busy (speaking, animating, etc.)."""
+        if self._is_busy_callback:
+            return self._is_busy_callback()
+        return False
+    async def _idle_loop(self) -> None:
+        """Main idle movement loop."""
+        logger.info("🌙 Idle movement service started")
+        next_movement_time = time.time() + random.uniform(3.0, 8.0)  # Start with a shorter initial wait
+        try:
+            while self._is_running:
+                now = time.time()
+                # Check if we should be idle
+                if self._is_paused or self._is_robot_busy():
+                    # Wait and check again
+                    await asyncio.sleep(0.5)
+                    # Reset movement timing when resuming
+                    next_movement_time = time.time() + random.uniform(2.0, 5.0)
+                    continue
+                # Check if it's time for a new movement
+                if now >= next_movement_time:
+                    # Decide what kind of movement
+                    if random.random() < 0.3:
+                        # Antenna-only twitch
+                        movement = AntennaOnlyMovement(self._current_pos)
+                        logger.debug(f"🎭 Antenna twitch (duration: {movement.duration:.1f}s)")
+                    else:
+                        # Full idle movement
+                        movement = IdleMovement()
+                        logger.debug(f"🎭 Idle movement: roll={movement.head_roll:.1f}° pitch={movement.head_pitch:.1f}° yaw={movement.head_yaw:.1f}° (duration: {movement.duration:.1f}s)")
+                    # Send the goto command - daemon handles interpolation
+                    target = movement.to_dict()
+                    success = await self._goto_pose(
+                        head_roll=target["head_roll"],
+                        head_pitch=target["head_pitch"],
+                        head_yaw=target["head_yaw"],
+                        antenna_left=target["antenna_left"],
+                        antenna_right=target["antenna_right"],
+                        duration=movement.duration,
+                    )
+                    if success:
+                        # Update our tracked position
+                        self._current_pos = target.copy()
+                        # Wait for movement to complete
+                        await asyncio.sleep(movement.duration + 0.2)
+                    # Schedule next movement
+                    next_movement_time = time.time() + random.uniform(*IDLE_INTERVAL_RANGE)
+                    logger.debug(f"Next idle movement in {next_movement_time - time.time():.1f}s")
+                else:
+                    # Wait a bit before checking again
+                    await asyncio.sleep(0.5)
+        except asyncio.CancelledError:
+            logger.debug("Idle movement loop cancelled")
+        except Exception as e:
+            logger.error(f"Error in idle movement loop: {e}")
+        finally:
+            # Return to neutral position on stop
+            await self._return_to_neutral()
+            logger.info("🌙 Idle movement service stopped")
+    async def _return_to_neutral(self) -> None:
+        """Smoothly return to neutral position."""
+        await self._goto_pose(
+            head_roll=0.0,
+            head_pitch=0.0,
+            head_yaw=0.0,
+            antenna_left=0.0,
+            antenna_right=0.0,
+            duration=1.5,
+        )
+        self._current_pos = NEUTRAL_POSITION.copy()
+        await asyncio.sleep(1.5)
+    async def start(self) -> None:
+        """Start the idle movement service."""
+        if self._is_running:
+            logger.debug("Idle movement service already running")
+            return
+        self._is_running = True
+        self._is_paused = False
+        self._idle_task = asyncio.create_task(self._idle_loop())
+        logger.info("🌙 Idle movement service starting...")
+    async def stop(self) -> None:
+        """Stop the idle movement service."""
+        if not self._is_running:
+            return
+        self._is_running = False
+        if self._idle_task:
+            self._idle_task.cancel()
+            try:
+                await self._idle_task
+            except asyncio.CancelledError:
+                pass
+            self._idle_task = None
+    async def close(self) -> None:
+        """Clean up resources."""
+        await self.stop()
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            self._client = None
+        logger.info("IdleMovementService closed")
+# Global singleton instance
+_idle_service: Optional[IdleMovementService] = None
+def get_idle_movement_service() -> Optional[IdleMovementService]:
+    """Get the global idle movement service instance."""
+    return _idle_service
+def set_idle_movement_service(service: IdleMovementService) -> None:
+    """Set the global idle movement service instance."""
+    global _idle_service
+    _idle_service = service
+    logger.info("Global IdleMovementService instance set")

reachy_ios_bridge/routes/__pycache__/voice.cpython-312.pyc CHANGED Viewed

Binary files a/reachy_ios_bridge/routes/__pycache__/voice.cpython-312.pyc and b/reachy_ios_bridge/routes/__pycache__/voice.cpython-312.pyc differ

reachy_ios_bridge/routes/conversation.py CHANGED Viewed

@@ -214,6 +214,9 @@ async def _handle_stop_command() -> None:
         if services.openai:
             services.openai.stop_listening()
         # Broadcast to iOS that listening has stopped
         await broadcast({
             "type": "listening_state",
@@ -733,6 +736,7 @@ async def _handle_start_listening(websocket: WebSocket) -> None:
 async def _handle_stop_listening(websocket: WebSocket) -> None:
     """Handle the stop_listening command."""
     services = get_services()
     create_tracked_task(send_goodbye())
@@ -743,6 +747,9 @@ async def _handle_stop_listening(websocket: WebSocket) -> None:
     services.openai.stop_listening()
     await websocket.send_json({
         "type": "listening_state",
         "listening": False,

         if services.openai:
             services.openai.stop_listening()
+        # Mark conversation as ended (allows idle movements to resume)
+        state.end_conversation()
         # Broadcast to iOS that listening has stopped
         await broadcast({
             "type": "listening_state",
 async def _handle_stop_listening(websocket: WebSocket) -> None:
     """Handle the stop_listening command."""
     services = get_services()
+    state = get_state()
     create_tracked_task(send_goodbye())
     services.openai.stop_listening()
+    # Mark conversation as ended (allows idle movements to resume)
+    state.end_conversation()
     await websocket.send_json({
         "type": "listening_state",
         "listening": False,

reachy_ios_bridge/routes/conversation_services.py CHANGED Viewed

@@ -69,6 +69,7 @@ class ConversationState:
     # Conversation tracking
     response_count: int = 0
     last_response_text: str = ""
     # Custom app state
     custom_emotion_animations: dict = field(default_factory=dict)
@@ -86,7 +87,12 @@ class ConversationState:
         """Reset state for a new conversation."""
         self.response_count = 0
         self.last_response_text = ""
         self.reset_for_new_response()
 # Global instances (initialized on first use)

     # Conversation tracking
     response_count: int = 0
     last_response_text: str = ""
+    is_active: bool = False  # True when a conversation is in progress
     # Custom app state
     custom_emotion_animations: dict = field(default_factory=dict)
         """Reset state for a new conversation."""
         self.response_count = 0
         self.last_response_text = ""
+        self.is_active = True  # Mark conversation as active
         self.reset_for_new_response()
+    def end_conversation(self) -> None:
+        """Mark conversation as ended."""
+        self.is_active = False
 # Global instances (initialized on first use)

reachy_ios_bridge/routes/games/__pycache__/tamareachy.cpython-312.pyc CHANGED Viewed

Binary files a/reachy_ios_bridge/routes/games/__pycache__/tamareachy.cpython-312.pyc and b/reachy_ios_bridge/routes/games/__pycache__/tamareachy.cpython-312.pyc differ

reachy_ios_bridge/routes/games/__pycache__/tamareachy_monitor.cpython-312.pyc ADDED Viewed

Binary file (7.76 kB). View file

reachy_ios_bridge/routes/games/tamareachy.py CHANGED Viewed

@@ -18,6 +18,7 @@ from .models import (
     TamaReachyCheckResponse,
 )
 from .helpers import speak_and_animate
 logger = logging.getLogger(__name__)
@@ -67,6 +68,10 @@ async def enable_tamareachy(request: TamaReachyEnableRequest):
         await speak_and_animate(commentary, "excited")
         logger.info("🐣 TamaReachy enabled!")
         return TamaReachyEnableResponse(
@@ -88,6 +93,10 @@ async def disable_tamareachy():
         await db.update_tamareachy_state({"enabled": False})
         # Sad goodbye message
         await speak_and_animate(
             "Goodbye for now... I'll miss you! 😢",
@@ -323,3 +332,13 @@ async def check_tamareachy_needs():
         logger.error(f"TamaReachy check failed: {e}")
         return TamaReachyCheckResponse(success=False, error=str(e))

     TamaReachyCheckResponse,
 )
 from .helpers import speak_and_animate
+from .tamareachy_monitor import get_tamareachy_monitor
 logger = logging.getLogger(__name__)
         await speak_and_animate(commentary, "excited")
+        # Start the background monitor
+        monitor = get_tamareachy_monitor()
+        await monitor.start()
         logger.info("🐣 TamaReachy enabled!")
         return TamaReachyEnableResponse(
         await db.update_tamareachy_state({"enabled": False})
+        # Stop the background monitor
+        monitor = get_tamareachy_monitor()
+        await monitor.stop()
         # Sad goodbye message
         await speak_and_animate(
             "Goodbye for now... I'll miss you! 😢",
         logger.error(f"TamaReachy check failed: {e}")
         return TamaReachyCheckResponse(success=False, error=str(e))
+@router.get("/monitor-status")
+async def get_monitor_status():
+    """Check if the background monitor is running."""
+    monitor = get_tamareachy_monitor()
+    return {
+        "monitor_running": monitor.is_running,
+        "check_interval_seconds": 5 * 60,
+    }

reachy_ios_bridge/routes/games/tamareachy_monitor.py ADDED Viewed

	@@ -0,0 +1,166 @@

+"""TamaReachy background monitor service.
+Periodically checks TamaReachy needs and triggers proactive speech
+even when the iOS app is not actively viewing the TamaReachy screen.
+"""
+import asyncio
+import logging
+from datetime import datetime
+from typing import Optional
+logger = logging.getLogger(__name__)
+# Check interval in seconds (5 minutes)
+CHECK_INTERVAL_SECONDS = 5 * 60
+class TamaReachyMonitorService:
+    """Background service that monitors TamaReachy needs.
+    Runs independently of the iOS app and checks for critical needs
+    every 5 minutes. When a need becomes critical, Reachy will speak
+    proactively to ask for care (respecting the 15-minute cooldown
+    between proactive requests).
+    """
+    def __init__(self):
+        """Initialize the monitor service."""
+        self._is_running = False
+        self._task: Optional[asyncio.Task] = None
+        logger.info("TamaReachyMonitorService initialized")
+    @property
+    def is_running(self) -> bool:
+        """Check if the monitor service is running."""
+        return self._is_running
+    async def start(self) -> None:
+        """Start the monitor service."""
+        if self._is_running:
+            logger.debug("TamaReachy monitor already running")
+            return
+        self._is_running = True
+        self._task = asyncio.create_task(self._monitor_loop())
+        logger.info("🐣 TamaReachy monitor started")
+    async def stop(self) -> None:
+        """Stop the monitor service."""
+        if not self._is_running:
+            return
+        self._is_running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+        logger.info("🐣 TamaReachy monitor stopped")
+    async def _monitor_loop(self) -> None:
+        """Main monitoring loop - runs every CHECK_INTERVAL_SECONDS."""
+        logger.info("🐣 TamaReachy monitor loop starting")
+        try:
+            while self._is_running:
+                # Wait first, then check (avoids immediate check on startup)
+                await asyncio.sleep(CHECK_INTERVAL_SECONDS)
+                if not self._is_running:
+                    break
+                await self._check_needs()
+        except asyncio.CancelledError:
+            logger.debug("TamaReachy monitor loop cancelled")
+        except Exception as e:
+            logger.error(f"Error in TamaReachy monitor: {e}", exc_info=True)
+    async def _check_needs(self) -> None:
+        """Check TamaReachy needs and speak if critical."""
+        try:
+            from ...database import get_database
+            from ...tools.tamareachy_engine import get_tamareachy_engine
+            from .helpers import speak_and_animate
+            db = get_database()
+            engine = get_tamareachy_engine()
+            state = await db.get_tamareachy_state()
+            # Only check if enabled
+            if not state.get("enabled", False):
+                logger.debug("🐣 TamaReachy not enabled, skipping check")
+                return
+            # Calculate decay based on time elapsed
+            decayed_stats = engine.calculate_decay(
+                state, state.get("last_decay_check")
+            )
+            # Update decayed stats in database
+            now = datetime.utcnow().isoformat()
+            await db.update_tamareachy_state({
+                **decayed_stats,
+                "last_decay_check": now,
+            })
+            # Check for critical need
+            critical_need = engine.get_critical_need(decayed_stats)
+            if critical_need and engine.should_make_proactive_request():
+                # Get message and reaction for this need
+                commentary = engine.get_request_message(critical_need)
+                reaction = engine.get_reaction_for_need(critical_need)
+                # Speak and animate
+                await speak_and_animate(commentary, reaction)
+                engine.mark_proactive_request_made()
+                logger.info(f"🐣 TamaReachy proactive request: {critical_need}")
+            else:
+                logger.debug(f"🐣 TamaReachy check complete (critical_need={critical_need})")
+        except Exception as e:
+            logger.error(f"🐣 TamaReachy check failed: {e}", exc_info=True)
+# Global singleton instance
+_monitor: Optional[TamaReachyMonitorService] = None
+def get_tamareachy_monitor() -> TamaReachyMonitorService:
+    """Get the global TamaReachy monitor service instance.
+    Creates the instance if it doesn't exist.
+    Returns:
+        The TamaReachy monitor service.
+    """
+    global _monitor
+    if _monitor is None:
+        _monitor = TamaReachyMonitorService()
+    return _monitor
+async def start_tamareachy_monitor_if_enabled() -> None:
+    """Start the TamaReachy monitor if TamaReachy is enabled.
+    Called on server startup to resume monitoring if TamaReachy
+    was previously enabled.
+    """
+    try:
+        from ...database import get_database
+        db = get_database()
+        state = await db.get_tamareachy_state()
+        if state.get("enabled", False):
+            monitor = get_tamareachy_monitor()
+            await monitor.start()
+            logger.info("🐣 TamaReachy monitor auto-started (was previously enabled)")
+    except Exception as e:
+        logger.warning(f"Could not check TamaReachy state on startup: {e}")

reachy_ios_bridge/routes/user_settings.py CHANGED Viewed

@@ -68,12 +68,30 @@ class UserCountryResponse(BaseModel):
     message: Optional[str] = None
 # =============================================================================
 # User Settings Keys
 # =============================================================================
 USER_NAME_KEY = "user_name"
 USER_COUNTRY_KEY = "preferred_country"
 # =============================================================================
@@ -259,6 +277,71 @@ async def delete_user_country() -> UserCountryResponse:
         raise HTTPException(status_code=500, detail=str(e))
 # =============================================================================
 # Helper Functions for Internal Use
 # =============================================================================

     message: Optional[str] = None
+class IdleMovementRequest(BaseModel):
+    """Request body for setting idle movement enabled state."""
+    enabled: bool = Field(
+        ...,
+        description="Whether idle movements are enabled"
+    )
+class IdleMovementResponse(BaseModel):
+    """Response for idle movement operations."""
+    success: bool
+    enabled: bool = True  # Default to enabled
+    message: Optional[str] = None
 # =============================================================================
 # User Settings Keys
 # =============================================================================
 USER_NAME_KEY = "user_name"
 USER_COUNTRY_KEY = "preferred_country"
+IDLE_MOVEMENT_KEY = "idle_movement_enabled"
 # =============================================================================
         raise HTTPException(status_code=500, detail=str(e))
+# =============================================================================
+# Idle Movement Routes
+# =============================================================================
+@router.get("/idle-movement", response_model=IdleMovementResponse)
+async def get_idle_movement_setting() -> IdleMovementResponse:
+    """Get the idle movement enabled setting.
+    Returns:
+        Whether idle movement is enabled (default: True).
+    """
+    try:
+        db = get_database()
+        value = await db.get_user_setting(IDLE_MOVEMENT_KEY)
+        # Default to enabled if not set
+        enabled = value != "false" if value is not None else True
+        return IdleMovementResponse(
+            success=True,
+            enabled=enabled,
+            message="Idle movement setting retrieved"
+        )
+    except Exception as e:
+        logger.error(f"Error getting idle movement setting: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+@router.post("/idle-movement", response_model=IdleMovementResponse)
+async def set_idle_movement_setting(request: IdleMovementRequest) -> IdleMovementResponse:
+    """Set whether idle movements are enabled.
+    Args:
+        request: Contains the enabled state.
+    Returns:
+        Confirmation with the stored state.
+    """
+    try:
+        from ..idle_movement_service import get_idle_movement_service
+        db = get_database()
+        await db.set_user_setting(IDLE_MOVEMENT_KEY, str(request.enabled).lower())
+        # Apply the setting immediately to the running service
+        idle_service = get_idle_movement_service()
+        if idle_service:
+            if request.enabled:
+                await idle_service.start()
+                logger.info("🌙 Idle movements enabled")
+            else:
+                await idle_service.stop()
+                logger.info("🌙 Idle movements disabled")
+        return IdleMovementResponse(
+            success=True,
+            enabled=request.enabled,
+            message=f"Idle movements {'enabled' if request.enabled else 'disabled'}"
+        )
+    except Exception as e:
+        logger.error(f"Error setting idle movement: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 # =============================================================================
 # Helper Functions for Internal Use
 # =============================================================================

reachy_ios_bridge/routes/voice.py CHANGED Viewed

@@ -12,6 +12,7 @@ from fastapi import APIRouter, HTTPException
 import httpx
 from ..models import Voice, VoiceRequest, VoiceResponse, VoicesListResponse
 logger = logging.getLogger(__name__)
@@ -97,6 +98,11 @@ class VoiceSettings:
     def preferred_language(self) -> str:
         return self._preferred_language
     def set_voice(self, voice_id: str) -> bool:
         """Set the current OpenAI voice. Returns True if successful."""
         valid_ids = [v["id"] for v in OPENAI_VOICES]
@@ -120,6 +126,11 @@ class VoiceSettings:
         self._current_language = language
         logger.info(f"🌍 Preferred language set to: {language}")
         return True
 # Singleton instance
@@ -327,6 +338,45 @@ async def set_preferred_language_endpoint(language: str = "en") -> dict:
         }
 # Sample phrases by language for voice testing
 VOICE_SAMPLE_PHRASES = {
     "en": {
@@ -559,9 +609,19 @@ async def test_voice(request: Optional[VoiceRequest] = None) -> dict:
 async def _play_pcm_audio(audio_data: bytes) -> None:
     """Play PCM audio data through Reachy's speaker.
     Args:
         audio_data: Raw PCM16 audio at 24kHz mono.
     """
     # OpenAI TTS PCM format: 24kHz, 16-bit signed little-endian, mono
     aplay_cmd = [
         "aplay",
@@ -575,16 +635,62 @@ async def _play_pcm_audio(audio_data: bytes) -> None:
     loop = asyncio.get_event_loop()
-    def _run_aplay():
-        process = subprocess.Popen(
-            aplay_cmd,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        stdout, stderr = process.communicate(input=audio_data, timeout=30)
-        if process.returncode != 0:
-            error_msg = stderr.decode() if stderr else "Unknown error"
-            raise RuntimeError(f"aplay failed: {error_msg}")
-    await loop.run_in_executor(None, _run_aplay)

 import httpx
 from ..models import Voice, VoiceRequest, VoiceResponse, VoicesListResponse
+from ..audio_playback import is_kids_mode_enabled, set_kids_mode
 logger = logging.getLogger(__name__)
     def preferred_language(self) -> str:
         return self._preferred_language
+    @property
+    def kids_mode(self) -> bool:
+        """Check if kids mode (pitch shifting) is enabled."""
+        return is_kids_mode_enabled()
     def set_voice(self, voice_id: str) -> bool:
         """Set the current OpenAI voice. Returns True if successful."""
         valid_ids = [v["id"] for v in OPENAI_VOICES]
         self._current_language = language
         logger.info(f"🌍 Preferred language set to: {language}")
         return True
+    def set_kids_mode(self, enabled: bool) -> None:
+        """Enable or disable kids mode (pitch shifting for younger voice)."""
+        set_kids_mode(enabled)
+        logger.info(f"🧒 Kids mode {'enabled' if enabled else 'disabled'}")
 # Singleton instance
         }
+# MARK: - Kids Mode Endpoints
+@router.get("/voice/kids-mode")
+async def get_kids_mode() -> dict:
+    """Get the current kids mode setting.
+    Kids mode pitch-shifts Reachy's voice to sound younger/child-like.
+    Returns:
+        kids_mode: Boolean indicating if kids mode is enabled.
+    """
+    return {
+        "kids_mode": _voice_settings.kids_mode,
+    }
+@router.post("/voice/kids-mode")
+async def set_kids_mode_endpoint(enabled: bool = False) -> dict:
+    """Enable or disable kids mode.
+    Kids mode pitch-shifts Reachy's voice to sound younger/child-like.
+    This applies a pitch shift to the audio output making the voice
+    sound more suitable for conversations with children.
+    Args:
+        enabled: True to enable kids mode, False to disable.
+    Returns:
+        Success status and current kids mode state.
+    """
+    _voice_settings.set_kids_mode(enabled)
+    return {
+        "success": True,
+        "kids_mode": enabled,
+        "message": f"Kids mode {'enabled' if enabled else 'disabled'}",
+    }
 # Sample phrases by language for voice testing
 VOICE_SAMPLE_PHRASES = {
     "en": {
 async def _play_pcm_audio(audio_data: bytes) -> None:
     """Play PCM audio data through Reachy's speaker.
+    Applies pitch shifting if kids mode is enabled.
     Args:
         audio_data: Raw PCM16 audio at 24kHz mono.
     """
+    import shutil
+    # Check if kids mode is enabled
+    use_pitch_shift = is_kids_mode_enabled() and shutil.which("sox") is not None
+    if is_kids_mode_enabled() and not shutil.which("sox"):
+        logger.warning("🧒 Kids mode enabled but sox not found, using normal playback")
     # OpenAI TTS PCM format: 24kHz, 16-bit signed little-endian, mono
     aplay_cmd = [
         "aplay",
     loop = asyncio.get_event_loop()
+    def _run_playback():
+        if use_pitch_shift:
+            # Pitch shift with sox, then pipe to aplay
+            # Sox command: read raw PCM, pitch shift, output raw PCM
+            sox_cmd = [
+                "sox",
+                "-t", "raw",
+                "-r", "24000",
+                "-e", "signed",
+                "-b", "16",
+                "-c", "1",
+                "-",  # Input from stdin
+                "-t", "raw",
+                "-",  # Output to stdout
+                "pitch", "400",  # Pitch shift up 400 cents
+            ]
+            # Create sox process
+            sox_process = subprocess.Popen(
+                sox_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            # Create aplay process reading from sox output
+            aplay_process = subprocess.Popen(
+                aplay_cmd,
+                stdin=sox_process.stdout,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            # Close sox stdout in parent
+            sox_process.stdout.close()
+            # Write audio to sox
+            sox_process.stdin.write(audio_data)
+            sox_process.stdin.close()
+            # Wait for both processes
+            sox_process.wait(timeout=30)
+            aplay_process.wait(timeout=30)
+            logger.info("🧒 Played audio with kids mode pitch shift")
+        else:
+            # Normal playback without pitch shifting
+            process = subprocess.Popen(
+                aplay_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            stdout, stderr = process.communicate(input=audio_data, timeout=30)
+            if process.returncode != 0:
+                error_msg = stderr.decode() if stderr else "Unknown error"
+                raise RuntimeError(f"aplay failed: {error_msg}")
+    await loop.run_in_executor(None, _run_playback)

reachy_ios_bridge/server.py CHANGED Viewed

@@ -14,11 +14,17 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from .database import init_database
 from .models import RobotStatus
 from .motion_service import MotionService
 from .tts_service import TTSService
 from .daemon_health_monitor import start_health_monitor, stop_health_monitor
 from .routes import (
     animations_router,
     apps_router,
@@ -49,13 +55,39 @@ logger = logging.getLogger(__name__)
 # Global service instances (will be initialized in lifespan)
 tts_service: TTSService | None = None
 motion_service: MotionService | None = None
 reachy_connected: bool = False
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """Manage application lifecycle."""
-    global tts_service, motion_service
     logger.info("Starting Reachy iOS Bridge server...")
@@ -63,10 +95,18 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     await init_database()
     logger.info("Database initialized")
     # Initialize services
     tts_service = TTSService()  # Uses OpenAI TTS API
     motion_service = MotionService()
     # Set global TTS service instance for other modules (like games)
     from .tts_service import set_tts_service
     set_tts_service(tts_service)
@@ -83,6 +123,27 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     health_monitor = start_health_monitor()
     logger.info("🏥 Daemon health monitor active - will auto-recover from motor errors")
     logger.info("Services initialized (waiting for Reachy connection...)")
     yield
@@ -90,6 +151,15 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     # Cleanup
     logger.info("Shutting down Reachy iOS Bridge server...")
     # Stop health monitor
     stop_health_monitor()
@@ -187,6 +257,91 @@ async def get_status() -> RobotStatus:
     )
 # External control functions (called by main.py)
 def set_reachy_connected(connected: bool) -> None:

 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
+from .config import get_config
 from .database import init_database
+from .idle_movement_service import IdleMovementService, set_idle_movement_service
 from .models import RobotStatus
 from .motion_service import MotionService
 from .tts_service import TTSService
 from .daemon_health_monitor import start_health_monitor, stop_health_monitor
+from .routes.games.tamareachy_monitor import (
+    get_tamareachy_monitor,
+    start_tamareachy_monitor_if_enabled,
+)
 from .routes import (
     animations_router,
     apps_router,
 # Global service instances (will be initialized in lifespan)
 tts_service: TTSService | None = None
 motion_service: MotionService | None = None
+idle_service: IdleMovementService | None = None
 reachy_connected: bool = False
+def _is_robot_busy() -> bool:
+    """Check if robot is currently busy with speech, animation, or conversation.
+    Used by idle movement service to pause during activity.
+    """
+    # Check TTS
+    if tts_service and tts_service.is_speaking:
+        return True
+    # Check motion/animation
+    if motion_service and motion_service.is_playing:
+        return True
+    # Check conversation state
+    try:
+        from .routes.conversation_services import get_state
+        state = get_state()
+        if state and state.is_active:
+            return True
+    except Exception:
+        pass
+    return False
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """Manage application lifecycle."""
+    global tts_service, motion_service, idle_service
     logger.info("Starting Reachy iOS Bridge server...")
     await init_database()
     logger.info("Database initialized")
+    # Load config
+    config = get_config()
     # Initialize services
     tts_service = TTSService()  # Uses OpenAI TTS API
     motion_service = MotionService()
+    # Initialize idle movement service with daemon URL from config
+    idle_service = IdleMovementService(daemon_url=config.daemon_url)
+    idle_service.set_busy_callback(_is_robot_busy)
+    set_idle_movement_service(idle_service)
     # Set global TTS service instance for other modules (like games)
     from .tts_service import set_tts_service
     set_tts_service(tts_service)
     health_monitor = start_health_monitor()
     logger.info("🏥 Daemon health monitor active - will auto-recover from motor errors")
+    # Start TamaReachy monitor if it was previously enabled
+    await start_tamareachy_monitor_if_enabled()
+    # Start idle movement service if enabled in settings (default: enabled)
+    try:
+        from .database import get_database
+        db = get_database()
+        idle_setting = await db.get_user_setting("idle_movement_enabled")
+        idle_enabled = idle_setting != "false" if idle_setting is not None else True
+        if idle_enabled:
+            await idle_service.start()
+            logger.info("🌙 Idle movement service active - Reachy will move subtly when idle")
+        else:
+            logger.info("🌙 Idle movement service disabled by user setting")
+    except Exception as e:
+        # If we can't read the setting, default to enabled
+        logger.warning(f"Could not read idle movement setting, defaulting to enabled: {e}")
+        await idle_service.start()
+        logger.info("🌙 Idle movement service active - Reachy will move subtly when idle")
     logger.info("Services initialized (waiting for Reachy connection...)")
     yield
     # Cleanup
     logger.info("Shutting down Reachy iOS Bridge server...")
+    # Stop idle movement service
+    if idle_service:
+        await idle_service.close()
+    # Stop TamaReachy monitor
+    tamareachy_monitor = get_tamareachy_monitor()
+    if tamareachy_monitor.is_running:
+        await tamareachy_monitor.stop()
     # Stop health monitor
     stop_health_monitor()
     )
+# Idle movement control endpoints
+@app.get("/api/idle", tags=["Idle Movement"])
+async def get_idle_status() -> dict:
+    """Get the current idle movement service status."""
+    if idle_service:
+        return {
+            "enabled": idle_service.is_running,
+            "paused": idle_service.is_paused,
+        }
+    return {
+        "enabled": False,
+        "paused": False,
+    }
+@app.post("/api/idle/enable", tags=["Idle Movement"])
+async def enable_idle_movement() -> dict:
+    """Enable idle movements when Reachy is not busy."""
+    if idle_service:
+        await idle_service.start()
+        return {
+            "success": True,
+            "message": "Idle movement enabled",
+        }
+    return {
+        "success": False,
+        "message": "Idle service not initialized",
+    }
+@app.post("/api/idle/disable", tags=["Idle Movement"])
+async def disable_idle_movement() -> dict:
+    """Disable idle movements."""
+    if idle_service:
+        await idle_service.stop()
+        return {
+            "success": True,
+            "message": "Idle movement disabled",
+        }
+    return {
+        "success": False,
+        "message": "Idle service not initialized",
+    }
+@app.post("/api/idle/test", tags=["Idle Movement"])
+async def test_idle_movement() -> dict:
+    """Manually trigger a test idle movement for debugging."""
+    if idle_service:
+        import random
+        # Generate a random movement
+        roll = random.uniform(-4.0, 4.0)
+        pitch = random.uniform(-3.0, 3.0)
+        yaw = random.uniform(-6.0, 6.0)
+        antenna_l = random.uniform(-15.0, 15.0)
+        antenna_r = random.uniform(-15.0, 15.0)
+        duration = 2.0
+        success = await idle_service._goto_pose(
+            head_roll=roll,
+            head_pitch=pitch,
+            head_yaw=yaw,
+            antenna_left=antenna_l,
+            antenna_right=antenna_r,
+            duration=duration,
+        )
+        return {
+            "success": success,
+            "movement": {
+                "head_roll": roll,
+                "head_pitch": pitch,
+                "head_yaw": yaw,
+                "antenna_left": antenna_l,
+                "antenna_right": antenna_r,
+                "duration": duration,
+            },
+        }
+    return {
+        "success": False,
+        "message": "Idle service not initialized",
+    }
 # External control functions (called by main.py)
 def set_reachy_connected(connected: bool) -> None:

style.css CHANGED Viewed

@@ -322,6 +322,11 @@ body {
     font-size: 1.1rem;
 }
 /* Features Grid */
 .features-grid {
     display: grid;
@@ -1108,3 +1113,199 @@ code {
         grid-template-columns: 1fr;
     }
 }

     font-size: 1.1rem;
 }
+.section-cta {
+    text-align: center;
+    margin-top: 2.5rem;
+}
 /* Features Grid */
 .features-grid {
     display: grid;
         grid-template-columns: 1fr;
     }
 }
+/* Documentation Page */
+.docs-page {
+    max-width: 900px;
+}
+.docs-header {
+    text-align: center;
+    margin-bottom: 4rem;
+}
+.docs-header h1 {
+    font-family: 'Mulish', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-size: 3rem;
+    font-weight: 800;
+    margin-bottom: 0.75rem;
+    background: linear-gradient(135deg, var(--text-primary), var(--accent));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+.docs-header p {
+    color: var(--text-secondary);
+    font-size: 1.25rem;
+}
+.docs-category {
+    margin-bottom: 4rem;
+}
+.docs-category > h2 {
+    font-family: 'Mulish', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-size: 1.75rem;
+    font-weight: 700;
+    margin-bottom: 1.5rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 2px solid var(--accent);
+    color: var(--text-primary);
+}
+.docs-feature {
+    background: var(--surface);
+    border-radius: 1rem;
+    border: 1px solid var(--border);
+    margin-bottom: 1.5rem;
+    overflow: hidden;
+    transition: all 0.2s;
+}
+.docs-feature:hover {
+    border-color: var(--accent);
+    box-shadow: 0 4px 20px var(--shadow);
+}
+.docs-feature-header {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 1.25rem 1.5rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+}
+.docs-icon {
+    font-size: 1.75rem;
+}
+.docs-feature-header h3 {
+    font-family: 'Mulish', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-size: 1.25rem;
+    font-weight: 700;
+    margin: 0;
+    color: var(--text-primary);
+}
+.docs-feature-content {
+    padding: 1.5rem;
+}
+.docs-feature-content > p {
+    color: var(--text-secondary);
+    font-size: 1rem;
+    line-height: 1.6;
+    margin-bottom: 1.25rem;
+}
+.docs-feature-content h4 {
+    font-family: 'Mulish', -apple-system, BlinkMacSystemFont, sans-serif;
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin-top: 1.25rem;
+    margin-bottom: 0.75rem;
+    color: var(--text-primary);
+}
+.docs-feature-content h4:first-of-type {
+    margin-top: 0;
+}
+.docs-feature-content ul {
+    list-style: none;
+    padding: 0;
+    margin: 0 0 1rem 0;
+}
+.docs-feature-content li {
+    color: var(--text-secondary);
+    padding: 0.35rem 0;
+    padding-left: 1.5rem;
+    position: relative;
+    font-size: 0.95rem;
+}
+.docs-feature-content li::before {
+    content: "→";
+    position: absolute;
+    left: 0;
+    color: var(--accent);
+}
+.docs-feature-content li strong {
+    color: var(--text-primary);
+}
+.docs-examples {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+.docs-examples code {
+    display: inline-block;
+    padding: 0.5rem 1rem;
+    background: var(--code-bg);
+    border-radius: 2rem;
+    font-size: 0.85rem;
+    color: var(--text-primary);
+    font-style: italic;
+    border: 1px solid var(--border);
+    font-family: 'Nunito', sans-serif;
+}
+.docs-note {
+    margin-top: 1rem;
+    padding: 0.75rem 1rem;
+    background: var(--bg-secondary);
+    border-radius: 0.5rem;
+    font-size: 0.9rem;
+    color: var(--text-secondary);
+    border-left: 3px solid var(--accent);
+}
+.docs-footer-nav {
+    display: flex;
+    justify-content: center;
+    gap: 1rem;
+    margin-top: 3rem;
+    padding-top: 2rem;
+    border-top: 1px solid var(--divider);
+}
+@media (max-width: 600px) {
+    .docs-header h1 {
+        font-size: 2rem;
+    }
+    .docs-category > h2 {
+        font-size: 1.35rem;
+    }
+    .docs-feature-header {
+        padding: 1rem 1.25rem;
+    }
+    .docs-feature-content {
+        padding: 1.25rem;
+    }
+    .docs-examples {
+        flex-direction: column;
+    }
+    .docs-examples code {
+        text-align: center;
+    }
+    .docs-footer-nav {
+        flex-direction: column;
+    }
+    .docs-footer-nav .btn {
+        width: 100%;
+        text-align: center;
+    }
+}