syact 0.15.0

A library that defines actuators and their interaction with each other
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

use embedded_hal::pwm::SetDutyCycle;
use syunit::*;

use crate::data::servo::ServoConst;

/// A basic servo motor with absolute position being controlled by a PWM signal
/// 
/// # Setup
/// 
/// In order to function correctly the servo has to be set up first!
/// - No pins will be occupied until the setup function is called
#[derive(Debug)]
pub struct MiniServo<P : SetDutyCycle> {
    /// The absolute position of the servo motor
    pos : PositionRad,
    /// The constants of the servo motor (depending on type)
    _consts : ServoConst,

    /// The PWM output signal
    pwm : P
}

impl<P : SetDutyCycle> MiniServo<P> {
    /// Creates a new servo driver with the given servo data `consts` connected to the `pin_pwm`
    /// 
    /// # Setup
    /// 
    /// Before any use of movement functions you must call `start()` or `setup()` in order to set up all the pins
    pub fn new(consts : ServoConst, pwm : P) -> Self {
        Self {
            pos: consts.default_pos(),
            _consts: consts,

            pwm
        }
    }
 
    /// Returns a reference to the `ServoConst` of the driver
    pub fn consts(&self) -> &ServoConst {
        &self._consts
    }

    // Drop
        /// Start the PWM signal and moves the servo to it's default position
        pub fn start(&mut self) -> Result<(), P::Error> {
            self.drive_default_pos()
        }

        /// Stops the servo driver and the PWM signal, can be started again with `start()` if desired
        pub fn stop(&mut self) -> Result<(), P::Error> {
            self.pwm.set_duty_cycle_fully_off()
        }
    //  

    // Absolute position
        /// Get the *aboslute* angle of the servo 
        pub fn pos(&self) -> PositionRad {
            self.pos
        }

        /// Set the absolute angle of the servo. Causes the servo to drive to this angle
        /// 
        /// # Panics
        /// 
        /// Panics if the given 
        pub fn drive_abs(&mut self, pos : PositionRad) -> Result<(), P::Error> {
            self.drive_factor_pos(Factor::try_new(pos / self._consts.position_max)
                .expect("The given position is either invalid or out of range!"))
        }
    // 
    
    // Factor
        /// Get the duty-cycle-percent of the motor (values `0.0` to `1.0`)
        pub fn factor(&self) -> Factor {
            // Safe to use, as all operations altering the Factor are internal
            unsafe { Factor::new_unchecked(self.pos / self._consts.position_max) }
        }

        /// Set the duty-cycle percent of the servo (value `0.0` to `1.0`). Causes the servo to adapt its position
        pub fn drive_factor_pos(&mut self, factor : Factor) -> Result<(), P::Error> {
            self.pwm.set_duty_cycle(factor.get_duty_for(self.pwm.max_duty_cycle()))
        }
    // 

    // Positions
        /// Moves the servo to its default position
        pub fn drive_default_pos(&mut self) -> Result<(), P::Error> {
            self.drive_factor_pos(Factor::HALF)
        }

        /// Moves the servo to its minimum endpoint
        pub fn drive_endpoint_min(&mut self) -> Result<(), P::Error> {
            self.drive_factor_pos(Factor::MIN)
        }

        /// Moves the servo to its maximum endpoint
        pub fn goto_endpoint_max(&mut self) -> Result<(), P::Error> {
            self.drive_factor_pos(Factor::MAX)
        }
    //
}