rrtk 0.7.0

Rust Robotics ToolKit: A data flow-based robotics framework designed for embedded systems.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// SPDX-License-Identifier: BSD-3-Clause
// Copyright 2024-2026 UxuginPython
#![cfg(feature = "devices")]
use core::convert::Infallible;
use rrtk::devices::provided::*;
use rrtk::devices::*;
use rrtk::*;
#[test]
fn clutch() {
    let mut system = System::<4>::new();
    let a_test = system.new_node().unwrap();
    let a_clutch = system.new_node().unwrap();
    system.connect(a_test, a_clutch);
    let b_test = system.new_node().unwrap();
    let b_clutch = system.new_node().unwrap();
    system.connect(b_test, b_clutch);
    const A: AngularState = AngularState::new(
        Dimensionless::new(1.0),
        InverseSecond::new(2.0),
        InverseSecondSquared::new(3.0),
    );
    const B: AngularState = AngularState::new(
        Dimensionless::new(4.0),
        InverseSecond::new(5.0),
        InverseSecondSquared::new(6.0),
    );
    system.set_state_local(a_test, Some(A));
    system.set_state_local(b_test, Some(B));

    let mut clutch = Clutch::new(a_clutch, b_clutch);
    <Clutch as DeviceUpdatable<Infallible>>::device_update(&mut clutch, &mut system);
    assert!(system.get_state_connected(a_test).is_none());
    assert!(system.get_state_connected(b_test).is_none());
    clutch.set_connected(true);
    <Clutch as DeviceUpdatable<Infallible>>::device_update(&mut clutch, &mut system);
    assert_eq!(system.get_state_connected(a_test), Some(B));
    assert_eq!(system.get_state_connected(b_test), Some(A));
    clutch.set_connected(false);
    <Clutch as DeviceUpdatable<Infallible>>::device_update(&mut clutch, &mut system);
    assert!(system.get_state_connected(a_test).is_none());
    assert!(system.get_state_connected(b_test).is_none());
}
#[test]
fn gear_train() {
    let mut system = System::<4>::new();
    let a_test = system.new_node().unwrap();
    let a_gear_train = system.new_node().unwrap();
    system.connect(a_test, a_gear_train);
    let b_test = system.new_node().unwrap();
    let b_gear_train = system.new_node().unwrap();
    system.connect(b_test, b_gear_train);
    const A: AngularState = AngularState::new(
        Dimensionless::new(1.0),
        InverseSecond::new(2.0),
        InverseSecondSquared::new(3.0),
    );
    const B: AngularState = AngularState::new(
        Dimensionless::new(4.0),
        InverseSecond::new(5.0),
        InverseSecondSquared::new(6.0),
    );
    system.set_state_local(a_test, Some(A));
    system.set_state_local(b_test, Some(B));

    let mut gear_train = GearTrain::new(a_gear_train, b_gear_train, Dimensionless::new(2.0));
    <GearTrain as DeviceUpdatable<Infallible>>::device_update(&mut gear_train, &mut system);
    assert_eq!(
        system.get_state_connected(a_test),
        Some(AngularState::new(
            Dimensionless::new(2.0),
            InverseSecond::new(2.5),
            InverseSecondSquared::new(3.0),
        ))
    );
    assert_eq!(
        system.get_state_connected(b_test),
        Some(AngularState::new(
            Dimensionless::new(2.0),
            InverseSecond::new(4.0),
            InverseSecondSquared::new(6.0),
        ))
    );
}
#[test]
fn differential() {
    let mut system = System::<6>::new();
    let a_test = system.new_node().unwrap();
    let a_differential = system.new_node().unwrap();
    system.connect(a_test, a_differential);
    let b_test = system.new_node().unwrap();
    let b_differential = system.new_node().unwrap();
    system.connect(b_test, b_differential);
    let c_test = system.new_node().unwrap();
    let c_differential = system.new_node().unwrap();
    system.connect(c_test, c_differential);
    const A: AngularState = AngularState::new(
        Dimensionless::new(1.0),
        InverseSecond::new(2.0),
        InverseSecondSquared::new(3.0),
    );
    const B: AngularState = AngularState::new(
        Dimensionless::new(4.0),
        InverseSecond::new(5.0),
        InverseSecondSquared::new(6.0),
    );
    const C: AngularState = AngularState::new(
        Dimensionless::new(7.0),
        InverseSecond::new(8.0),
        InverseSecondSquared::new(9.0),
    );
    system.set_state_local(a_test, Some(A));
    system.set_state_local(b_test, Some(B));
    system.set_state_local(c_test, Some(C));

    let mut differential = Differential::new(a_differential, b_differential, c_differential);
    <Differential as DeviceUpdatable<Infallible>>::device_update(&mut differential, &mut system);
    assert_eq!(system.get_state_connected(a_test), Some(C - B));
    assert_eq!(system.get_state_connected(b_test), Some(C - A));
    assert_eq!(system.get_state_connected(c_test), Some(A + B));
}
#[test]
fn same_system() {
    let mut system_ab = System::<2>::new();
    let node_a = system_ab.new_node().unwrap();
    let node_b = system_ab.new_node().unwrap();
    let mut system_c = System::<1>::new();
    let node_c = system_c.new_node().unwrap();
    assert!(node_a.same_system(node_a));
    assert!(node_b.same_system(node_b));
    assert!(node_c.same_system(node_c));
    assert!(node_a.same_system(node_b));
    assert!(node_b.same_system(node_a));
    assert!(!node_a.same_system(node_c));
    assert!(!node_b.same_system(node_c));
    assert!(!node_c.same_system(node_a));
    assert!(!node_c.same_system(node_b));
}