ashv2 9.0.1

Implementation of the Asynchronous Serial Host (ASH) protocol.
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

use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

use serialport::SerialPort;
use tokio::sync::mpsc::WeakSender;
use tokio::task::JoinHandle;

pub use self::error::Error;
use crate::actor::message::Message;

mod error;

/// Running `ASHv2` actor tasks.
///
/// `Tasks` owns the spawned receiver, transmitter, and serial worker handles. Use
/// [`Tasks::terminate`] to shut them down and recover the original serial port.
#[derive(Debug)]
pub struct Tasks<T> {
    handle: JoinHandle<T>,
    transmitter: JoinHandle<()>,
    receiver: JoinHandle<()>,
    sender: WeakSender<Message>,
    running: Arc<AtomicBool>,
}

impl<T> Tasks<T>
where
    T: SerialPort + Send + 'static,
{
    /// Create new tasks from a split serial port handle and actor components.
    pub(crate) const fn new(
        handle: JoinHandle<T>,
        transmitter: JoinHandle<()>,
        receiver: JoinHandle<()>,
        sender: WeakSender<Message>,
        running: Arc<AtomicBool>,
    ) -> Self {
        Self {
            handle,
            transmitter,
            receiver,
            sender,
            running,
        }
    }
}

impl<T> Tasks<T> {
    /// Terminate the actor tasks and return the original serial port.
    ///
    /// # Errors
    ///
    /// Returns [`Error`] if sending the termination message fails or joining any task fails.
    pub async fn terminate(self) -> Result<T, Error> {
        self.running.store(false, Relaxed);
        self.receiver.await?;

        if let Some(sender) = self.sender.upgrade() {
            sender.send(Message::Terminate).await?;
        }

        self.transmitter.await?;
        let serial_port = self.handle.await?;
        Ok(serial_port)
    }
}