boomerang 0.3.0

Deterministic Middleware for Robotics
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 boomerang::{builder::prelude::*, runtime, Reaction, Reactor};

#[derive(Reactor)]
#[reactor(state = "()", reaction = "SourceReactionT")]
struct SourceBuilder {
    y: TypedPortKey<i32, Output>,
    #[reactor(timer())]
    t: TimerActionKey,
}

#[derive(Reaction)]
#[reaction(reactor = "SourceBuilder", triggers(action = "t"))]
struct SourceReactionT<'a> {
    y: runtime::OutputRef<'a, i32>,
}

impl Trigger<SourceBuilder> for SourceReactionT<'_> {
    fn trigger(mut self, _ctx: &mut runtime::Context, _state: &mut ()) {
        *self.y = Some(1);
    }
}

#[derive(Reactor)]
#[reactor(state = "()", reaction = "DestReactionXY")]
struct DestinationBuilder {
    x: TypedPortKey<i32, Input>,
    y: TypedPortKey<i32, Input>,
}

#[derive(Reaction)]
#[reaction(reactor = "DestinationBuilder")]
struct DestReactionXY<'a> {
    x: runtime::InputRef<'a, i32>,
    y: runtime::InputRef<'a, i32>,
}

impl Trigger<DestinationBuilder> for DestReactionXY<'_> {
    fn trigger(self, _ctx: &mut runtime::Context, _state: &mut ()) {
        let mut sum = 0;
        if let Some(x) = *self.x {
            sum += x;
        }
        if let Some(y) = *self.y {
            sum += y;
        }
        println!("Received {}", sum);
        assert_eq!(sum, 2, "FAILURE: Expected 2.");
    }
}

#[derive(Reactor)]
#[reactor(state = "()", reaction = "PassReactionX")]
struct PassBuilder {
    x: TypedPortKey<i32, Input>,
    y: TypedPortKey<i32, Output>,
}

#[derive(Reaction)]
#[reaction(reactor = "PassBuilder")]
struct PassReactionX<'a> {
    x: runtime::InputRef<'a, i32>,
    y: runtime::OutputRef<'a, i32>,
}

impl Trigger<PassBuilder> for PassReactionX<'_> {
    fn trigger(mut self, _ctx: &mut runtime::Context, _state: &mut ()) {
        *self.y = *self.x;
    }
}

#[derive(Reactor)]
#[reactor(
    state = "()",
    connection(from = "s.y", to = "d.y"),
    connection(from = "s.y", to = "p1.x"),
    connection(from = "p1.y", to = "p2.x"),
    connection(from = "p2.y", to = "d.x")
)]
#[allow(dead_code)]
struct DeterminismBuilder {
    #[reactor(child = "()")]
    s: SourceBuilder,
    #[reactor(child = "()")]
    d: DestinationBuilder,
    #[reactor(child = "()")]
    p1: PassBuilder,
    #[reactor(child = "()")]
    p2: PassBuilder,
}

#[test]
fn determinism() {
    tracing_subscriber::fmt::init();
    let _ = boomerang_util::runner::build_and_test_reactor::<DeterminismBuilder>(
        "determinism",
        (),
        true,
        false,
    )
    .unwrap();
}