prinThor 0.0.3

The highly reliable but not necessarily functional 3D Printer firmware
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

//! A synchronization primitive for polling values from a task.
//! Basically, an copy of embassy_sync::Signal with a dirty hack to not loose the consumed value
use core::cell::Cell;
use core::future::{poll_fn, Future};
use core::task::{Context, Poll, Waker};
use embassy_sync::blocking_mutex::Mutex;
use embassy_sync::blocking_mutex::raw::RawMutex;

#[allow(unused)]
pub struct Config<M, T>
    where
        M: RawMutex, T: Send + Copy
{
    state: Mutex<M, Cell<State<T>>>,
}

#[allow(unused)]
#[derive(Clone)]
enum State<T> where T: Send + Copy {
    None,
    Waiting(Waker),
    Signaled(T),
}

#[allow(unused)]
impl<M, T> Config<M, T>
    where
        M: RawMutex, T: Send + Copy
{
    /// Create a new `Signal`.
    pub const fn new() -> Self {
        Self {
            state: Mutex::new(Cell::new(State::None)),
        }
    }
}

#[allow(unused)]
impl<M, T> Default for Config<M, T>
    where
        M: RawMutex, T: Send + Copy
{
    fn default() -> Self {
        Self::new()
    }
}

#[allow(unused)]
impl<M, T> Config<M, T>
    where
        M: RawMutex,
        T: Send + Copy
{
    /// Mark this Signal as signaled.
    pub fn signal(&self, val: T) {
        self.state.lock(|cell| {
            //info!("signal -> Replacing to {}", val);
            let state = cell.replace(State::Signaled(val));
            if let State::Waiting(waker) = state {
                waker.wake();
            }
        })
    }

    /// Remove the queued value in this `Config`, if any.
    pub fn reset(&self) {
        self.state.lock(|cell| cell.set(State::None));
    }

    fn poll_wait(&self, cx: &mut Context<'_>) -> Poll<T> {
        self.state.lock(|cell| {

            let state = cell.replace(State::None);

            match state {
                State::None => {
                    //info!("Poll State::None");
                    cell.set(State::Waiting(cx.waker().clone()));
                    Poll::Pending
                }
                State::Waiting(w) if w.will_wake(cx.waker()) => {
                    //info!("Poll State::Waiting.1");
                    cell.set(State::Waiting(w));
                    Poll::Pending
                }
                State::Waiting(w) => {
                    //info!("Poll State::Waiting.2");
                    cell.set(State::Waiting(cx.waker().clone()));
                    w.wake();
                    Poll::Pending
                }
                State::Signaled(r) => {
                    //info!("Poll State::Signaled cv=({})", r);
                    cell.set(State::Signaled(r));
                    Poll::Ready(r)
                },
            }
        })
    }

    /// Future that completes when this Signal has been signaled.
    pub fn wait(&self) -> impl Future<Output = T> + '_ {
        poll_fn(move |cx| self.poll_wait(cx))
    }

    /// non-blocking method to check whether this signal has been signaled.
    pub fn signaled(&self) -> bool {
        self.state.lock(|cell| {
            let state = cell.replace(State::None);

            let res = matches!(state, State::Signaled(_));

            cell.set(state);

            res
        })
    }
}