Method process_events

bvr/firmware/crates/control-loop/src/dispatch_handler.rs:41–101

Process pending dispatch events from the receiver

(
        &self,
        dispatch_rx: &mut Option<mpsc::Receiver<DispatchEvent>>,
        current_mode: Mode,
    )

    /// Process pending dispatch events from the receiver
    pub fn process_events(
        &self,
        dispatch_rx: &mut Option<mpsc::Receiver<DispatchEvent>>,
        current_mode: Mode,
    ) -> DispatchResult {
        let mut result = DispatchResult::default();

        let rx = match dispatch_rx {
            Some(rx) => rx,
            None => return result,
        };

        while let Ok(event) = rx.try_recv() {
            match event {
                DispatchEvent::TaskAssigned(assignment) => {
                    info!(
                        task_id = %assignment.task_id,
                        mission_id = %assignment.mission_id,
                        waypoints = assignment.zone.waypoints.len(),
                        is_loop = assignment.zone.is_loop,
                        "Task assigned from dispatch"
                    );

                    result.task_assigned = Some(assignment);

                    // Request autonomous mode if currently idle
                    match current_mode {
                        Mode::Idle => {
                            result.request_autonomous = true;
                            info!("Requesting transition to Autonomous mode for dispatch task");
                        }
                        Mode::Teleop => {
                            info!("Task queued - currently in Teleop mode");
                        }
                        Mode::Autonomous => {
                            info!("New task received while autonomous");
                        }
                        _ => {}
                    }
                }
                DispatchEvent::TaskCancelled(task_id) => {
                    info!(task_id = %task_id, "Task cancelled by dispatch");
                    result.task_cancelled = Some(task_id);
                }
                DispatchEvent::CommandReceived(cmd) => {
                    info!(?cmd, "Voice command received via dispatch");
                    result.commands.push(cmd);
                }
                DispatchEvent::Connected(connected) => {
                    if connected {
                        info!("Connected to dispatch service");
                    } else {
                        warn!("Disconnected from dispatch service");
                    }
                    result.connection_changed = Some(connected);
                }
            }
        }