pros-devices 0.2.1

High level device for pros-rs
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

//! Rotation sensor device.
//!
//! Rotation sensors operate on the same [`Position`] type as motors to measure rotation.

use pros_core::{bail_on, error::PortError};
use pros_sys::PROS_ERR;

use super::{SmartDevice, SmartDeviceType, SmartPort};
use crate::position::Position;

/// A physical rotation sensor plugged into a port.
#[derive(Debug, Eq, PartialEq)]
pub struct RotationSensor {
    port: SmartPort,
    /// Whether or not the sensor direction is reversed.
    pub reversed: bool,
}

impl RotationSensor {
    /// Creates a new rotation sensor on the given port.
    /// Whether or not the sensor should be reversed on creation can be specified.
    pub fn new(port: SmartPort, reversed: bool) -> Result<Self, PortError> {
        unsafe {
            bail_on!(PROS_ERR, pros_sys::rotation_reset_position(port.index()));
            if reversed {
                bail_on!(
                    PROS_ERR,
                    pros_sys::rotation_set_reversed(port.index(), true)
                );
            }
        }

        Ok(Self { port, reversed })
    }

    /// Sets the position to zero.
    pub fn zero(&mut self) -> Result<(), PortError> {
        unsafe {
            bail_on!(
                PROS_ERR,
                pros_sys::rotation_reset_position(self.port.index())
            );
        }
        Ok(())
    }

    /// Sets the position.
    pub fn set_position(&mut self, position: Position) -> Result<(), PortError> {
        unsafe {
            bail_on!(
                PROS_ERR,
                pros_sys::rotation_set_position(
                    self.port.index(),
                    (position.into_counts() * 100) as _
                )
            );
        }
        Ok(())
    }

    /// Sets whether or not the rotation sensor should be reversed.
    pub fn set_reversed(&mut self, reversed: bool) -> Result<(), PortError> {
        self.reversed = reversed;

        unsafe {
            bail_on!(
                PROS_ERR,
                pros_sys::rotation_set_reversed(self.port.index(), reversed)
            );
        }
        Ok(())
    }

    /// Reverses the rotation sensor.
    pub fn reverse(&mut self) -> Result<(), PortError> {
        self.set_reversed(!self.reversed)
    }

    //TODO: See if this is accurate enough or consider switching to get_position function.
    /// Gets the current position of the sensor.
    pub fn position(&self) -> Result<Position, PortError> {
        Ok(unsafe {
            Position::from_degrees(
                bail_on!(PROS_ERR, pros_sys::rotation_get_angle(self.port.index())) as f64 / 100.0,
            )
        })
    }
}

impl SmartDevice for RotationSensor {
    fn port_index(&self) -> u8 {
        self.port.index()
    }

    fn device_type(&self) -> SmartDeviceType {
        SmartDeviceType::Rotation
    }
}