robot-control 0.1.2

A Rust library for controlling DC motor robots via PCA9685 PWM boards over I2C
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Exercise the public API with a downstream-style custom driver.
use std::sync::{Arc, Mutex as StdMutex};
use std::time::Duration;

use robot_control::{Motor, MotorDriver, MotorError, Robot, RobotConfig, RobotError};
use tokio::sync::Mutex;

#[derive(Clone, Default)]
struct RecordingDriver(Arc<StdMutex<Vec<(Motor, u16, bool)>>>);

impl MotorDriver for RecordingDriver {
    fn set_motor_speed(&self, motor: Motor, speed: u16, forward: bool) -> Result<(), MotorError> {
        self.0.lock().unwrap().push((motor, speed, forward));
        Ok(())
    }

    fn stop_motor(&self, motor: Motor) -> Result<(), MotorError> {
        self.0.lock().unwrap().push((motor, 0, false));
        Ok(())
    }
}

#[tokio::test(start_paused = true)]
async fn saturated_commands_reach_driver_as_bounded_pwm() {
    let driver = RecordingDriver::default();
    let log = driver.0.clone();
    // Explicit literal ensures no mandatory public fields have been added.
    let config = RobotConfig {
        left_motor: Motor::Motor1,
        right_motor: Motor::Motor4,
        left_motor_factor: f32::MAX,
        right_motor_factor: -f32::MAX,
        adjustment_step: 1.0,
        adjustment_interval: Duration::from_millis(10),
    };
    let robot = Robot::new(Arc::new(Mutex::new(driver)), config).unwrap();
    for (demand, left_forward, right_forward) in [(f32::MAX, true, false), (-f32::MAX, false, true)]
    {
        robot.drive(demand, demand).await.unwrap();
        // Two ticks also allow a full +1 to -1 transition at step 1.
        for _ in 0..2 {
            tokio::task::yield_now().await;
            tokio::time::advance(Duration::from_millis(10)).await;
            tokio::task::yield_now().await;
        }
        let commands = log.lock().unwrap().clone();
        assert!(commands.iter().all(|(_, pwm, _)| *pwm <= 4095));
        assert_eq!(
            &commands[commands.len() - 2..],
            &[
                (Motor::Motor1, 4095, left_forward),
                (Motor::Motor4, 4095, right_forward)
            ]
        );
    }
    robot.drive(0.0, 0.0).await.unwrap();
    tokio::time::advance(Duration::from_millis(10)).await;
    tokio::task::yield_now().await;
    let commands = log.lock().unwrap().clone();
    assert_eq!(
        &commands[commands.len() - 2..],
        &[(Motor::Motor1, 0, false), (Motor::Motor4, 0, false)]
    );
    robot.shutdown().await;
}

// Compile exhaustive matches to preserve the existing error enum surface.
fn existing_error_api(error: RobotError) -> String {
    match error {
        RobotError::Shutdown => "shutdown".into(),
        RobotError::Motor(error) => match error {
            MotorError::Init(message) | MotorError::Pwm(message) | MotorError::I2c(message) => {
                message
            }
        },
    }
}

#[tokio::test]
async fn invalid_input_reports_through_existing_error_api() {
    let robot = Robot::new(
        Arc::new(Mutex::new(RecordingDriver::default())),
        RobotConfig::default(),
    )
    .unwrap();
    let message = existing_error_api(robot.drive(0.5, f32::NAN).await.unwrap_err());
    assert!(message.contains("finite"));
    robot.shutdown().await;
}