{
  "action": "forward" | "backward" | "strafe_left" | "strafe_right" | "rotate_left" | "rotate_right" | "stop",
  "distance": 1.0,  // meters (for linear movement)
  "angle": 90,       // degrees (for rotation)
  "speed": 0.5       // 0.0-1.0, optional, defaults to config max_speed
}

{
  "success": true,
  "output": "Moved forward 1.5 meters"
}

{
  "action": "capture" | "describe" | "find",
  "prompt": "a red ball",  // optional, for "find" action
  "save_path": "/tmp/image.jpg"  // optional, defaults to temp file
}

{
  "success": true,
  "output": "I see a couch, a TV on the wall, and some toys on the floor. The room is well-lit with natural light from a window."
}

[camera]
vision_model = "moondream"
ollama_url = "http://localhost:11434"

{
  "duration": 5,  // seconds to record
  "language": "en"  // optional, defaults to "en"
}

{
  "success": true,
  "output": "Hey Buddy, can you help me find my toy?"
}

[audio]
whisper_model = "base"
whisper_path = "/usr/local/bin/whisper-cpp"

{
  "text": "Hello! I'm ready to play!",
  "voice": "en_US-lessac-medium"  // optional, defaults to config
}

{
  "success": true,
  "output": "Spoke: Hello! I'm ready to play!"
}

{
  "action": "scan" | "motion" | "distance",
  "direction": "front" | "all",  // for scan action
  "max_range": 5.0  // meters, optional
}

{
  "success": true,
  "output": "Front: clear (2.3m), Left: obstacle at 0.8m, Right: clear (3.1m)"
}

[sensors]
lidar_port = "/dev/ttyUSB0"
lidar_type = "rplidar"
motion_pins = [17, 27]
ultrasonic_pins = [23, 24]

{
  "expression": "happy" | "sad" | "excited" | "thinking" | "sleepy" | "surprised",
  "sound": "beep" | "chime" | "buzz"  // optional
}

{
  "success": true,
  "output": "Displayed: happy face"
}

Happy:    Sad:      Excited:  Thinking:
  ● ●       ● ●       ● ●         ● ●
  ● ●       ● ●       ● ●         ○ ●
                                    
 ●●●●●     ●●●●●     ●●●●●       ●●●

pub struct ToolResult {
    pub success: bool,
    pub output: String,
    pub error: Option<String>,
}

{
  "success": false,
  "output": "",
  "error": "Obstacle detected at 0.2m, stopping"
}

{
  "success": false,
  "output": "",
  "error": "Camera device /dev/video0 not found"
}

{
  "success": false,
  "output": "",
  "error": "E-stop pressed, all movement disabled"
}

use zeroclaw_robot_kit::*;

#[tokio::main]
async fn main() {
    let config = RobotConfig::default();
    let tools = create_tools(&config);
    
    // Game sequence
    speak("I'll count to 20. Go hide!");
    emote("excited");
    tokio::time::sleep(Duration::from_secs(20)).await;
    
    speak("Ready or not, here I come!");
    
    loop {
        let obstacles = sense("scan", "all");
        drive("forward", 1.0);
        let scene = look("find", "a child hiding");
        
        if scene.contains("child") {
            speak("Found you!");
            emote("happy", Some("chime"));
            break;
        }
    }
}

loop {
    speak("Where should I go?");
    let command = listen(5).await?;
    
    match command.as_str() {
        cmd if cmd.contains("forward") => drive("forward", 1.0),
        cmd if cmd.contains("back") => drive("backward", 0.5),
        cmd if cmd.contains("left") => drive("rotate_left", 90),
        cmd if cmd.contains("right") => drive("rotate_right", 90),
        cmd if cmd.contains("stop") => {
            drive("stop", 0.0);
            break;
        },
        _ => speak("I didn't understand that"),
    }
}

loop {
    // Check for obstacles
    let scan = sense("scan", "front");
    if scan.min_distance < 0.5 {
        speak("Obstacle ahead, turning");
        drive("rotate_right", 90);
        continue;
    }
    
    // Check for motion
    let motion = sense("motion");
    if motion.detected {
        speak("I see movement!");
        let scene = look("describe");
        speak(&format!("I see: {}", scene));
    }
    
    // Continue patrol
    drive("forward", 2.0);
}

use zeroclaw_robot_kit::{SafetyMonitor, SafeDrive, DriveTool};

let config = RobotConfig::default();

// Create safety monitor
let (safety, safety_rx) = SafetyMonitor::new(config.safety.clone());
let safety = Arc::new(safety);

// Start sensor feed
tokio::spawn(async move {
    loop {
        let reading = get_lidar_data().await;
        safety.update_sensor(reading).await;
    }
});

// Wrap drive with safety
let drive = Arc::new(DriveTool::new(config.clone()));
let safe_drive = SafeDrive::new(drive, safety.clone());

// Now all drive commands go through safety checks
safe_drive.execute(json!({"action": "forward", "distance": 2.0})).await;

pub enum SafetyEvent {
    ObstacleDetected { distance: f64, angle: i32 },
    BumpSensorTriggered { sensor: String },
    EStopPressed,
    SensorTimeout,
    SpeedLimited { from: f64, to: f64, reason: String },
    MovementBlocked { reason: String },
}

# Check backend
grep backend ~/.zeroclaw/robot.toml

# Serial: verify port
ls /dev/ttyACM*

# ROS2: check topic
ros2 topic list | grep cmd_vel

# Test in mock mode
sed -i 's/backend = ".*"/backend = "mock"/' ~/.zeroclaw/robot.toml

# List cameras
ls /dev/video*
ffmpeg -f v4l2 -list_formats all -i /dev/video0

# Check permissions
sudo usermod -aG video $USER

# Check Ollama is running
curl http://localhost:11434/api/tags

# Test vision model
ollama run moondream "Describe this image: /tmp/test.jpg"

# Use smaller model
sed -i 's/vision_model = ".*"/vision_model = "moondream"/' ~/.zeroclaw/robot.toml

# Check sensor readings
tail -f /tmp/zeroclaw_sensors.fifo

# Increase safety thresholds (testing only!)
sed -i 's/min_obstacle_distance = 0.3/min_obstacle_distance = 0.15/' ~/.zeroclaw/robot.toml

# Disable safety (dangerous!)
sed -i 's/predict_collisions = true/predict_collisions = false/' ~/.zeroclaw/robot.toml