ergot 0.12.0

Eloquence in messaging
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
138
139
140
141
142

use cobs_acc::{CobsAccumulator, FeedResult};
use embedded_io_async_0_6::Read;

use crate::interface_manager::profiles::direct_edge::CENTRAL_NODE_ID;
use crate::{
    interface_manager::{
        InterfaceState, Profile,
        interface_impls::embedded_io::IoInterface,
        profiles::direct_edge::{DirectEdge, process_frame},
    },
    net_stack::NetStackHandle,
};

pub type EmbeddedIoManager<Q> = DirectEdge<IoInterface<Q>>;

pub struct RxWorker<N, R>
where
    N: NetStackHandle,
    R: Read,
{
    nsh: N,
    rx: R,
    net_id: Option<u16>,
    ident: <<N as NetStackHandle>::Profile as Profile>::InterfaceIdent,
    is_controller: bool,
}

impl<N, R> RxWorker<N, R>
where
    N: NetStackHandle,
    R: Read,
{
    /// Create a new RX worker in target mode.
    ///
    /// In target mode, we will receive our net_id/node_id assignments from our
    /// controller.
    pub fn new_target(
        net: N,
        rx: R,
        ident: <<N as NetStackHandle>::Profile as Profile>::InterfaceIdent,
    ) -> Self {
        Self {
            nsh: net,
            rx,
            net_id: None,
            ident,
            is_controller: false,
        }
    }

    /// Create a new RX worker in controller mode.
    ///
    /// In controller mode, we will hardcode our net_id/node_id to `1.1`, allowing
    /// us to speak to a target.
    pub fn new_controller(
        net: N,
        rx: R,
        ident: <<N as NetStackHandle>::Profile as Profile>::InterfaceIdent,
    ) -> Self {
        Self {
            nsh: net,
            rx,
            net_id: None,
            ident,
            is_controller: true,
        }
    }

    pub async fn run(&mut self, frame: &mut [u8], scratch: &mut [u8]) -> Result<(), R::Error> {
        // Mark the interface as established
        _ = self.nsh.stack().manage_profile(|im| {
            if self.is_controller {
                self.net_id = Some(1);
                im.set_interface_state(
                    self.ident.clone(),
                    InterfaceState::Active {
                        net_id: 1,
                        node_id: CENTRAL_NODE_ID,
                    },
                )
            } else {
                self.net_id = None;
                im.set_interface_state(self.ident.clone(), InterfaceState::Inactive)
            }
        });
        let res = self.run_inner(frame, scratch).await;
        _ = self
            .nsh
            .stack()
            .manage_profile(|im| im.set_interface_state(self.ident.clone(), InterfaceState::Down));
        res
    }

    pub async fn run_inner(
        &mut self,
        frame: &mut [u8],
        scratch: &mut [u8],
    ) -> Result<(), R::Error> {
        let mut acc = CobsAccumulator::new(frame);
        let Self {
            nsh,
            rx,
            net_id,
            ident,
            is_controller: _,
        } = self;
        'outer: loop {
            let used = rx.read(scratch).await?;
            let mut remain = &mut scratch[..used];

            loop {
                match acc.feed_raw(remain) {
                    FeedResult::Consumed => continue 'outer,
                    FeedResult::OverFull(items) => {
                        remain = items;
                    }
                    FeedResult::DecodeError(items) => {
                        remain = items;
                    }
                    FeedResult::Success { data, remaining }
                    | FeedResult::SuccessInput { data, remaining } => {
                        process_frame(net_id, data, nsh, ident.clone());
                        remain = remaining;
                    }
                }
            }
        }
    }
}

impl<N, R> Drop for RxWorker<N, R>
where
    N: NetStackHandle,
    R: Read,
{
    fn drop(&mut self) {
        // No receiver? Drop the interface.
        self.nsh.stack().manage_profile(|im| {
            _ = im.set_interface_state(self.ident.clone(), InterfaceState::Down);
        })
    }
}