nxt 0.2.1

USB driver for communicating with the NXT brick
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use gilrs::{Button, Event, EventType::AxisChanged, Gilrs};
use nxt::{
    motor::{OutMode, OutPort, RegulationMode, RunState, RUN_FOREVER},
    Nxt,
};
use std::time::{Duration, Instant};

type Result = std::result::Result<(), Box<dyn std::error::Error>>;

const MIN_TIME_BETWEEN_UPDATES: Duration = Duration::from_millis(100);

#[derive(Debug)]
struct Robot {
    nxt: Nxt,
    speed: i8,
    steering: i8,
    changed: bool,
}

impl Robot {
    pub fn new(nxt: Nxt) -> Self {
        Self {
            nxt,
            speed: 0,
            steering: 0,
            changed: false,
        }
    }

    pub fn set_speed(&mut self, speed: f32) {
        debug_assert!((-1.0..=1.0).contains(&speed));
        self.speed = (speed * 100.0).trunc() as i8;
        self.changed = true;
    }

    pub fn set_steering(&mut self, steering: f32) {
        debug_assert!((-1.0..=1.0).contains(&steering));
        self.steering = (steering * 100.0).trunc() as i8;
        self.changed = true;
    }

    pub fn changed(&self) -> bool {
        self.changed
    }

    pub async fn send(&mut self) -> Result {
        self.nxt
            .set_output_state(
                OutPort::BC,
                self.speed,
                OutMode::ON,
                RegulationMode::Idle,
                self.steering,
                RunState::Running,
                RUN_FOREVER,
            )
            .await?;
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result {
    let mut gilrs = Gilrs::new().unwrap();

    // Iterate over all connected gamepads
    for (_id, gamepad) in gilrs.gamepads() {
        println!("{} is {:?}", gamepad.name(), gamepad.power_info());
    }

    let nxt = Nxt::first_usb().await?;

    let mut active_gamepad = None;
    let mut robot = Robot::new(nxt);
    let mut last_update = Instant::now();

    loop {
        // Examine new events
        while let Some(Event {
            id,
            event,
            time: _time,
        }) = gilrs.next_event()
        {
            #[cfg(debug_assertions)]
            println!("{:?} New event from {}: {:?}", _time, id, event);
            active_gamepad = Some(id);
            if let AxisChanged(axis, pos, _) = event {
                match axis {
                    gilrs::Axis::LeftStickX => robot.set_steering(pos),
                    gilrs::Axis::LeftStickY => robot.set_speed(pos),
                    gilrs::Axis::LeftZ => (),
                    gilrs::Axis::RightStickX => (),
                    gilrs::Axis::RightStickY => (),
                    gilrs::Axis::RightZ => (),
                    gilrs::Axis::DPadX => (),
                    gilrs::Axis::DPadY => (),
                    gilrs::Axis::Unknown => (),
                }
            }
        }

        if last_update.elapsed() > MIN_TIME_BETWEEN_UPDATES {
            last_update = Instant::now();
            if robot.changed() {
                println!("{robot:?}");
                robot.send().await?;
            }
        }

        // You can also use cached gamepad state
        if let Some(gamepad) = active_gamepad.map(|id| gilrs.gamepad(id)) {
            if gamepad.is_pressed(Button::South) {
                println!("Button South is pressed (XBox - A, PS - X)");
                break;
            }
        }
    }

    Ok(())
}