Edit ultrasonic.rs structure and implement in main.rs

src/main.rs

@@ -11,6 +11,8 @@ use motors::Motor;
 mod config;
 use config::Config;
 
+mod ultrasonic;
+
 fn main() -> Result<(), Box<dyn Error>> {
     let config = Config::new();
     println!(
@@ -21,6 +23,16 @@ fn main() -> Result<(), Box<dyn Error>> {
         config.left2
     );
 
+    // Read front distance
+
+    let mut ultrasonic = Ultrasonic::new();
+
+    if let Some(dist) = ultrasonic.get_front_dist() {
+        println!("Front distance: {}", dist);
+    } else {
+        println!("No reading");
+    }
+
     let gpio = Gpio::new()?;
 
     // LEFT

src/moduleTests/motorTest.rs

@@ -1,50 +1,45 @@
-use raslib::L298n;
+use rppal::gpio::{Gpio};
-use std::thread;
+use rppal::pwm::{Pwm, Channel, Polarity};
-use std::time::Duration;
+use std::{error::Error, thread, time::Duration};
 
-// struct L298n {
+mod motors;
-//   in1: Gpio,
+use motors::Motor;
-//   in2: Gpio,
-//   ena: Gpio,
-// }
 
-fn main() -> Result<(), std::io::Error> {
+mod config;
-    let mut motor_front_left = L298n::new(0, 0, 0);
+use config::Config;
-    let mut motor_front_right = L298n::new(0, 0, 0);
-    let mut motor_rear_left = L298n::new(0, 0, 0);
-    let mut motor_rear_right = L298n::new(0, 0, 0);
 
-    // Front left test
+fn main() -> Result<(), Box<dyn Error>> {
+    let config = Config::new();
+    let gpio = Gpio::new()?;
 
-    motor_front_left.forward()?;
+    let left = Motor {
+        in1: gpio.get(27)?.into_output(),
+        in2: gpio.get(22)?.into_output(),
+        pwm: Pwm::with_frequency(Channel::Pwm0, 1000.0, 0.0, Polarity::Normal, true)?,
+    };
+
+    let right = Motor {
+        in1: gpio.get(23)?.into_output(),
+        in2: gpio.get(24)?.into_output(),
+        pwm: Pwm::with_frequency(Channel::Pwm1, 1000.0, 0.0, Polarity::Normal, true)?,
+    };
+
+    let mut left = left;
+    let mut right = right;
+
+    // Forwards 3 seconds
+    left.forward(1.0);
+    right.forward(1.0);
+    thread::sleep(Duration::from_secs(3));
+
+    // Backwards 3 seconds
+    left.backward(0.6);
+    right.backward(0.6);
     thread::sleep(Duration::from_secs(2));
-    motor_front_left.backward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_front_left.stop()?;
 
-    // Front right test
+    // Stop both motors
-
+    left.stop();
-    motor_front_right.forward()?;
+    right.stop();
-    thread::sleep(Duration::from_secs(2));
-    motor_front_right.backward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_front_right.stop()?;
-
-    // Rear left test
-
-    motor_rear_left.forward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_rear_left.backward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_rear_left.stop()?;
-
-    // Rear right test
-
-    motor_rear_right.forward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_rear_right.backward()?;
-    thread::sleep(Duration::from_secs(2));
-    motor_rear_right.stop()?;
 
     Ok(())
 }

src/ultrasonic.rs

@@ -1,53 +1,35 @@
 use hc_sr04::{HcSr04, Unit};
 
-let mut ultrasonic_front = HcSr04::new(
+pub struct Ultrasonic {
-    7,          // TRIGGER
+    front: HcSr04,
-    1,          // ECHO
+    left: HcSr04,
-    Some(23_f32) 
+    right: HcSr04,
-).unwrap();
+    rear: HcSr04,
-
-let mut ultrasonic_left = HcSr04::new(
-    0,
-    4,
-    Some(23_f32) 
-).unwrap();
-
-let mut ultrasonic_right = HcSr04::new(
-    2,
-    5,
-    Some(23_f32) 
-).unwrap();
-
-let mut ultrasonic_rear = HcSr04::new(
-    3,
-    6,
-    Some(23_f32) 
-).unwrap();
-
-fn get_front_dist() -> Option<i32> {
-	match ultrasonic_front.measure_distance(Unit::Meters).unwrap() {
-    		Some(dist) => Some(dist),
-    		None => None,
-	}
 }
 
-fn get_left_dist() -> Option<i32> {
+impl Ultrasonic {
-        match ultrasonic_left.measure_distance(Unit::Meters).unwrap() {
+    pub fn new() -> Self {
-                Some(dist) => Some(dist),
+        Self {
-                None => None,
+            front: HcSr04::new(7, 1, Some(23.0)).unwrap(),
+            left: HcSr04::new(0, 4, Some(23.0)).unwrap(),
+            right: HcSr04::new(2, 5, Some(23.0)).unwrap(),
+            rear: HcSr04::new(3, 6, Some(23.0)).unwrap(),
         }
-}
+    }
 
-fn get_right_dist() -> Option<i32> {
+    pub fn get_front_dist(&mut self) -> Option<i32> {
-        match ultrasonic_right.measure_distance(Unit::Meters).unwrap() {
+        self.front.measure_distance(Unit::Meters).ok().flatten()
-                Some(dist) => Some(dist),
+    }
-                None => None,
-        }
-}
 
-fn get_rear_dist() -> Option<i32> {
+    pub fn get_left_dist(&mut self) -> Option<i32> {
-        match ultrasonic_rear.measure_distance(Unit::Meters).unwrap() {
+        self.left.measure_distance(Unit::Meters).ok().flatten()
-                Some(dist) => Some(dist),
+    }
-                None => None,
+
-        }
+    pub fn get_right_dist(&mut self) -> Option<i32> {
+        self.right.measure_distance(Unit::Meters).ok().flatten()
+    }
+
+    pub fn get_rear_dist(&mut self) -> Option<i32> {
+        self.rear.measure_distance(Unit::Meters).ok().flatten()
+    }
 }