syact 0.12.1-alpha

A library to control motors (mainly stepper motors) and components, read data from sensors and more
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

use serde::{Serialize, Deserialize};

use crate::{SyncActuator, Setup};
use crate::act::parent::{ActuatorParent, RatioActuatorParent};
use syunit::*;

/// A linear axis
#[derive(Debug, Serialize, Deserialize)]
pub struct LinearAxis<A : SyncActuator> {
    /// The child component driving the linear axis
    pub actuator : A,

    /// Distance traveled per rad (Unit mm)   \
    /// `f_rte = pitch / (2pi)`
    pub rte_ratio : f32
}

impl<A : SyncActuator> LinearAxis<A> {
    /// Create a new linear axis instance
    /// - `device`: The parent component driving the linear axis
    /// - `rte_ratio`: (radius to extension ratio), millimeters travelled per radian the spindle rotated
    ///   - `f_rte = pitch / (2pi)`
    pub fn new(device : A, rte_ratio : f32) -> Self {
        return LinearAxis {
            actuator: device,
            rte_ratio
        };
    }
}

impl<A : SyncActuator> Setup for LinearAxis<A> {
    fn setup(&mut self) -> Result<(), crate::Error> {
        self.actuator.setup()
    }
}

// Parent
    impl<A : SyncActuator> ActuatorParent for LinearAxis<A> {
        type Child = A;

        fn child(&self) -> &Self::Child {
            &self.actuator
        }

        fn child_mut(&mut self) -> &mut Self::Child {
            &mut self.actuator
        }
    }

    impl<A : SyncActuator> RatioActuatorParent for LinearAxis<A> {
        fn ratio(&self) -> f32 {
            self.rte_ratio
        }

        // Correct unit conversions
            fn force_for_child(&self, parent_force : Force) -> Force {
                parent_force * (self.ratio() / 1000.0)  // Ratio in millimeters => Conversion to meters for Newtonmeters
            }

            fn force_for_parent(&self, child_force : Force) -> Force {
                child_force / (self.ratio() / 1000.0)   // Ratio in millimeters => Conversion to meters for Newtonmeters 
            }

            fn inertia_for_child(&self, parent_inertia : Inertia) -> Inertia {
                parent_inertia * (self.ratio() / 1000.0) * (self.ratio() / 1000.0)
            }

            fn inertia_for_parent(&self, child_intertia : Inertia) -> Inertia {
                child_intertia / (self.ratio() / 1000.0) / (self.ratio() / 1000.0)
            }
        // 
    }
//