Method execute_command

examples/grid-operator/safety_bounded_grid.rs:234–303

Execute control command with safety verification

(&mut self, command: ControlCommand)

    /// Execute control command with safety verification
    pub fn execute_command(&mut self, command: ControlCommand) -> Result<SafetyProof, String> {
        let start = std::time::Instant::now();

        // Step 1: Check safety envelope
        let envelope_satisfied = self.check_envelope(&command);
        if !envelope_satisfied {
            return Err("Safety envelope violation".to_string());
        }

        // Step 2: Check human exclusion
        let humans_excluded = self.check_human_exclusion(&command);
        if !humans_excluded {
            self.near_miss_count += 1;
            return Err("Human exclusion zone violation".to_string());
        }

        // Step 3: Check torque limits
        let torque_ok = self.check_torque(&command);
        if !torque_ok {
            return Err("Torque limit exceeded".to_string());
        }

        // Step 4: Check failsafe
        let failsafe_ready = self.check_failsafe(&command.robot_id);
        if !failsafe_ready {
            return Err("Failsafe not ready".to_string());
        }

        // Step 5: Simulate execution
        let simulated_outcome = self.simulate(&command);

        // Step 6: Update robot state
        if let Some(robot) = self.robots.get_mut(&command.robot_id) {
            robot.position_x = command.target_x;
            robot.position_y = command.target_y;
            robot.speed_mps = command.target_speed;
            robot.torque_nm = command.target_torque;
            robot.status = RobotStatus::Moving;
        }

        self.command_history.push(command.clone());

        let latency = start.elapsed();

        // Verify real-time performance: control loop should be <100ms
        if latency.as_millis() > 100 {
            eprintln!(
                "Warning: Control latency {}ms exceeds 100ms target",
                latency.as_millis()
            );
        }

        // Step 7: Generate proof
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();