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
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

use crate::tests::SimPin;
use crate as syact;

use syact::prelude::*;

fn test<G : SyncActuatorGroup<T, 2>, T : SyncActuator + ?Sized + 'static>(_g : &G) {
    
}

#[derive(StepperActuatorGroup)]
struct SomeComps {
    base : Gear<Stepper<SimPin, SimPin>>,
    arm1 : LinearAxis<Stepper<SimPin, SimPin>>
}

#[test]
fn group_basics() -> Result<(), syact::Error> {
    let mut group = SomeComps {
        base: Gear::new(
            Stepper::new_gen(),
            0.2
        ),
        arm1: LinearAxis::new(
            Stepper::new_gen(),
            0.5
        )
    }; 
    test(&group);

    group.set_config(StepperConfig::GEN);
    group.setup()
}

// // Manual
// struct ManualGroup {
//     base : Gear<Stepper>,
//     arm1 : Gear<Stepper>
// }

// impl Setup for ManualGroup {
//     fn setup(&mut self) -> Result<(), syact::Error> {
//         self.base.setup()?;
//         self.arm1.setup()
//     }
// }

// impl<T : SyncActuator + 'static> SyncActuatorGroup<T, 2> for ManualGroup 
// where
//     Gear<Stepper> : AsRef<T>
// {
//     fn for_each<'a, F, R>(&'a self, mut func : F) -> [R; 2]
//         where 
//             F : FnMut(&'a T, usize) -> R 
//     {
//         let mut result : [R; 2] = unsafe { core::mem::zeroed() };

//         result[0] = func(self.base.as_ref(), 0);

//         result
//     }

//     fn for_each_mut<F, R>(&mut self, func : F) -> [R; 2]
//     where 
//         F : FnMut(&mut T, usize) -> R {
//         todo!()
//     }

//     fn try_for_each<'a, F, R, E>(&'a self, func : F) -> Result<[R; 2], E>
//     where 
//         F : FnMut(&'a T, usize) -> Result<R, E> {
//         todo!()
//     }

//     fn try_for_each_mut<F, R, E>(&mut self, func : F) -> Result<[R; 2], E>
//     where 
//         F : FnMut(&mut T, usize) -> Result<R, E> {
//         todo!()
//     }
// }

// pub fn test_manual<G : SyncActuatorGroup<T, 2>, T : SyncActuator + 'static>(_group_ref : &G) 
// where
//     Gear<Stepper> : AsRef<T>
// {
//     todo!()
// }

// #[test]
// fn group_manual() {
//     let group = ManualGroup {
//         base: Gear::new(
//             Stepper::new_gen(),
//             0.2
//         ),
//         arm1: Gear::new(
//             Stepper::new_gen(),
//             0.2
//         )
//     };

//     test_manual(&group);
// }