fix: fixed compiler errors in main file, fixed trait mismatch, resolved compiler warnings

Author: SarangaR

src/main.rs

@@ -14,19 +14,12 @@ use sw8s_rust_lib::{
     missions::{
         action::ActionExec,
         action_context::FullActionContext,
-        align_buoy::{buoy_align, buoy_align_shot},
         basic::descend_and_go_forward,
         bin::bin,
-        circle_buoy::{
-            buoy_circle_sequence, buoy_circle_sequence_blind, buoy_circle_sequence_model,
-        },
-        coinflip::{coinflip, coinflip_procedural},
+        coinflip::coinflip_procedural,
         example::{initial_descent, pid_test},
         fire_torpedo::{FireLeftTorpedo, FireRightTorpedo},
-        gate::{
-            gate_run_complex, gate_run_cv_procedural, gate_run_dead_reckon, gate_run_naive,
-            gate_run_procedural, gate_run_testing,
-        },
+        gate::{gate_run_cv_procedural, gate_run_dead_reckon, gate_run_procedural},
         meb::WaitArm,
         octagon::octagon,
         path_align::{path_align_procedural, static_align_procedural},
@@ -37,15 +30,14 @@ use sw8s_rust_lib::{
         vision::PIPELINE_KILL,
     },
     video_source::appsink::Camera,
-    vision::buoy::Target,
     TIMESTAMP,
 };
 use tokio::{
     io::WriteHalf,
     signal,
     sync::{
         mpsc::{self, UnboundedSender},
-        OnceCell, RwLock, Semaphore,
+        OnceCell, Semaphore,
     },
     time::{sleep, timeout},
 };
@@ -129,13 +121,6 @@ async fn bottom_cam() -> &'static Camera {
         .await
 }
 
-static GATE_TARGET: OnceCell<RwLock<Target>> = OnceCell::const_new();
-async fn gate_target() -> &'static RwLock<Target> {
-    GATE_TARGET
-        .get_or_init(|| async { RwLock::new(Target::Earth1) })
-        .await
-}
-
 static STATIC_CONTEXT: OnceCell<FullActionContext<WriteHalf<SerialStream>>> = OnceCell::const_new();
 async fn static_context() -> &'static FullActionContext<'static, WriteHalf<SerialStream>> {
     STATIC_CONTEXT
@@ -145,7 +130,6 @@ async fn static_context() -> &'static FullActionContext<'static, WriteHalf<Seria
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             )
         })
         .await
@@ -369,23 +353,6 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
             meb().await,
             front_cam().await,
             bottom_cam().await,
-            gate_target().await,
-        ))
-        .execute()),
-        "gate_run_naive" => ctwrap!(gate_run_naive(&FullActionContext::new(
-            control_board().await,
-            meb().await,
-            front_cam().await,
-            bottom_cam().await,
-            gate_target().await,
-        ))
-        .execute()),
-        "gate_run_complex" => ctwrap!(gate_run_complex(&FullActionContext::new(
-            control_board().await,
-            meb().await,
-            front_cam().await,
-            bottom_cam().await,
-            gate_target().await,
         ))
         .execute()),
         "gate_run_coinflip" => ctwrap!(gate_run_cv_procedural(
@@ -394,7 +361,6 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             ),
             &config.missions.gate,
             &config.get_color_profile().unwrap(),
@@ -405,7 +371,6 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             ),
             &config.missions.gate
         )),
@@ -415,19 +380,9 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             ),
             &config.missions.gate,
-            &config.get_color_profile().unwrap(),
         )),
-        "gate_run_testing" => ctwrap!(gate_run_testing(&FullActionContext::new(
-            control_board().await,
-            meb().await,
-            front_cam().await,
-            bottom_cam().await,
-            gate_target().await,
-        ))
-        .execute()),
         "start_cam" => {
             // This has not been tested
             logln!("Opening camera");
@@ -442,7 +397,6 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             ),
             &config.missions.path_align,
             &config.get_color_profile().unwrap(),
@@ -453,7 +407,6 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
                 meb().await,
                 front_cam().await,
                 bottom_cam().await,
-                gate_target().await,
             ),
             &config.missions.path_align,
         )),
@@ -462,15 +415,13 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
             meb().await,
             front_cam().await,
             bottom_cam().await,
-            gate_target().await,
         ))
         .execute()),
         "pid_test" => ctwrap!(pid_test(&FullActionContext::new(
             control_board().await,
             meb().await,
             front_cam().await,
             bottom_cam().await,
-            gate_target().await,
         ))
         .execute()),
         "octagon" => ctwrap!(octagon(
@@ -479,22 +430,7 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
             &config.get_color_profile().unwrap()
         )
         .execute()),
-        "buoy_circle" => ctwrap!(buoy_circle_sequence(&FullActionContext::new(
-            control_board().await,
-            meb().await,
-            front_cam().await,
-            bottom_cam().await,
-            gate_target().await,
-        ))
-        .execute()),
-        "buoy_model" => ctwrap!(buoy_circle_sequence_model(static_context().await).execute()),
-        "buoy_blind" => ctwrap!(buoy_circle_sequence_blind(static_context().await).execute()),
-        "buoy_align" => ctwrap!(buoy_align(static_context().await).execute()),
-        "spin" => ctwrap!(spin(static_context().await).execute()),
-        "torpedo" | "fire_torpedo" => {
-            let _ = buoy_align_shot(static_context().await).execute().await;
-            Ok(())
-        }
+        "spin" => ctwrap!(spin(static_context().await, &config.missions.spin)),
         "torpedo_only" => {
             FireRightTorpedo::new(static_context().await)
                 .execute()
@@ -538,7 +474,7 @@ async fn run_mission(mission: &str, cancel: CancellationToken) -> Result<()> {
             let _ = sonar(static_context().await, &config.sonar, cancel).await;
             Ok(())
         }
-        "bin" => ctwrap!(bin(static_context().await, &config.missions.bin)),
+        "bin" => ctwrap!(bin(static_context().await)),
         x => bail!("Invalid argument: [{x}]"),
     };
 

src/missions/gate.rs

@@ -105,7 +105,7 @@ pub async fn gate_run_cv_procedural<
         .stability_2_speed_set(0.0, 0.0, 0.0, 0.0, initial_yaw, config.depth)
         .await;
 
-    const TOLERANCE: f32 = 0.3;
+    // const TOLERANCE: f32 = 0.3;
 
     let mut gate_state = GateState::Align;
     let mut yaw_target = 0.0;
@@ -120,25 +120,25 @@ pub async fn gate_run_cv_procedural<
             vec![]
         });
 
-        let leftPole = detections.iter().filter(|d| *d.class()).collect_vec();
-        let leftPole_avg_x = leftPole
+        let left_pole = detections.iter().filter(|d| *d.class()).collect_vec();
+        let left_pole_avg_x = left_pole
             .iter()
             .map(|d| *d.position().x() as f32)
             .sum::<f32>();
 
-        let rightPole = detections.iter().filter(|d| !*d.class()).collect_vec();
-        let rightPole_avg_x = rightPole
+        let right_pole = detections.iter().filter(|d| !*d.class()).collect_vec();
+        let right_pole_avg_x = right_pole
             .iter()
             .map(|d| *d.position().x() as f32)
             .sum::<f32>();
 
         match gate_state {
             GateState::Align => match config.side {
                 Side::Left => {
-                    if leftPole.len() > 0 {
+                    if left_pole.len() > 0 {
                         false_count = 0;
-                        let mut correction;
-                        if leftPole_avg_x < 0.2 {
+                        let correction;
+                        if left_pole_avg_x < 0.2 {
                             true_count += 1;
                             if true_count >= config.true_count {
                                 #[cfg(feature = "logging")]
@@ -153,7 +153,7 @@ pub async fn gate_run_cv_procedural<
                                 logln!("true_count: {true_count}/4");
                             }
                         } else {
-                            correction = dbg!(config.correction_factor * leftPole_avg_x);
+                            correction = dbg!(config.correction_factor * left_pole_avg_x);
                             let _ = cb
                                 .stability_1_speed_set(0.0, 0.0, correction, 0.0, 0.0, config.depth)
                                 .await;
@@ -185,10 +185,10 @@ pub async fn gate_run_cv_procedural<
                 }
 
                 Side::Right => {
-                    if rightPole.len() > 0 {
+                    if right_pole.len() > 0 {
                         false_count = 0;
-                        let mut correction;
-                        if rightPole_avg_x < 0.2 {
+                        let correction;
+                        if right_pole_avg_x < 0.2 {
                             true_count += 1;
                             if true_count >= config.true_count {
                                 #[cfg(feature = "logging")]
@@ -203,7 +203,7 @@ pub async fn gate_run_cv_procedural<
                                 logln!("true_count: {true_count}/4");
                             }
                         } else {
-                            correction = dbg!(config.correction_factor * rightPole_avg_x);
+                            correction = dbg!(config.correction_factor * right_pole_avg_x);
                             let _ = cb
                                 .stability_1_speed_set(0.0, 0.0, correction, 0.0, 0.0, config.depth)
                                 .await;
@@ -322,10 +322,10 @@ pub async fn gate_run_procedural<
             vec![]
         });
 
-        let rightPole = detections
-            .iter()
-            .filter(|d| matches!(d.class().identifier, Target::RightPole))
-            .collect_vec();
+        // let right_pole = detections
+        //     .iter()
+        //     .filter(|d| matches!(d.class().identifier, Target::RightPole))
+        //     .collect_vec();
 
         /* let middle = detections
         .iter()

src/missions/octagon.rs

@@ -45,6 +45,8 @@ pub fn octagon<
     config: &Config,
     color_profile: &ColorProfile,
 ) -> impl ActionExec<()> + 'static {
+    let _ = config;
+    let _ = color_profile;
     const FULL_SPEED_Y: f32 = 0.7;
     const FULL_SPEED_X: f32 = 0.0;
     const FULL_SPEED_PITCH: f32 = -45.0 / 4.0;

src/missions/slalom.rs

@@ -7,7 +7,7 @@ use tokio_serial::SerialStream;
 use super::action_context::{FrontCamIO, GetControlBoard, GetMainElectronicsBoard};
 use crate::{
     config::{slalom::Config, ColorProfile, Side::*},
-    missions::{action::ActionExec, basic::DelayAction, vision::VisionNormAngle},
+    missions::{action::ActionExec, vision::VisionNormAngle},
 };
 
 // TODO: Consider filtering detections by angle (poles will always be upright)
@@ -90,10 +90,12 @@ pub async fn slalom<
                     let x = *position.x() as f32;
                     dbg!(&x);
                     let mut correction = 0.0;
+                    let _ = correction;
                     if x.abs() < 0.2 {
                         true_count += 1;
                         if true_count >= 4 {
                             correction = 0.0;
+                            let _ = correction;
                             #[cfg(feature = "logging")]
                             logln!("ALIGNED");
                             slalom_state = SlalomState::Approach;

src/missions/spin.rs

@@ -37,10 +37,12 @@ pub async fn spin<
     let mut spin_count = 0;
     let mut in_spin = false;
 
-    cb.stability_2_speed_set(0.0, 0.0, 0.0, 0.0, initial_yaw, config.depth)
+    let _ = cb
+        .stability_2_speed_set(0.0, 0.0, 0.0, 0.0, initial_yaw, config.depth)
         .await;
     sleep(Duration::from_secs(1)).await;
-    cb.global_speed_set(0.0, 0.0, 0.0, 0.0, config.spin_speed, 0.0)
+    let _ = cb
+        .global_speed_set(0.0, 0.0, 0.0, 0.0, config.spin_speed, 0.0)
         .await;
 
     loop {
@@ -75,6 +77,7 @@ pub async fn spin<
             break;
         }
     }
-    cb.stability_2_speed_set(0.0, 0.0, 0.0, 0.0, initial_yaw, config.depth)
+    let _ = cb
+        .stability_2_speed_set(0.0, 0.0, 0.0, 0.0, initial_yaw, config.depth)
         .await;
 }

src/vision/gate_poles.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
 use derive_getters::Getters;
 use opencv::core::{multiply, BORDER_CONSTANT, CV_8U};
-use opencv::imgproc::morphology_default_border_value;
+use opencv::imgproc::{dilate, morphology_default_border_value};
 use opencv::{
-    core::imerge, split, Point, Scalar, Size, Vector},
-    prelude::{Mat, MatTraitConst, MatTraitConstManual},
+    core::{merge, split, Point, Size, Vector},
+    prelude::{Mat, MatTraitConst},
 };
 
 use crate::load_onnx;

src/vision/mod.rs

@@ -478,3 +478,24 @@ impl Mul<&Mat> for PosVector {
         }
     }
 }
+
+impl Draw for VisualDetection<bool, Offset2D<f64>> {
+    fn draw(&self, canvas: &mut Mat) -> anyhow::Result<()> {
+        let color = if self.class {
+            Scalar::from((0.0, 255.0, 0.0))
+        } else {
+            Scalar::from((0.0, 0.0, 255.0))
+        };
+
+        imgproc::circle(
+            canvas,
+            Point::new(*self.position.x() as i32, *self.position.y() as i32),
+            10,
+            color,
+            2,
+            LINE_8,
+            0,
+        )?;
+        Ok(())
+    }
+}

src/vision/slalom.rs

@@ -73,8 +73,8 @@ impl VisualDetector<f64> for Slalom {
         input_image: &Mat,
     ) -> anyhow::Result<Vec<VisualDetection<Self::ClassEnum, Self::Position>>> {
         let areas = self.area_bounds.clone();
-        let MIN_AREA = areas.start();
-        let MAX_AREA = areas.end();
+        let min_area = areas.start();
+        let max_area = areas.end();
 
         self.image = resize(input_image, &self.size)?.into();
         let mut yuv_image = Mat::default();
@@ -114,7 +114,7 @@ impl VisualDetector<f64> for Slalom {
             #[cfg(feature = "logging")]
             logln!("AREA: {area}");
 
-            if area > *MIN_AREA && area < *MAX_AREA {
+            if area > *min_area && area < *max_area {
                 let rect = min_area_rect(&contour)?;
 
                 let mut box_rect = Mat::default();