drogue_esp8266/
ingress.rs

1use crate::{buffer::Buffer, protocol::Response};
2use heapless::{
3    consts::{U16, U2},
4    spsc::Producer,
5};
6
7use embedded_hal::serial::Read;
8use nb::Error;
9
10pub struct Ingress<'a, Rx>
11    where
12        Rx: Read<u8>,
13{
14    rx: Rx,
15    response_producer: Producer<'a, Response, U2>,
16    notification_producer: Producer<'a, Response, U16>,
17    buffer: Buffer,
18}
19
20impl<'a, Rx> Ingress<'a, Rx>
21    where
22        Rx: Read<u8>,
23{
24    pub fn new(
25        rx: Rx,
26        response_producer: Producer<'a, Response, U2>,
27        notification_producer: Producer<'a, Response, U16>,
28    ) -> Self {
29        Self {
30            rx,
31            response_producer,
32            notification_producer,
33            buffer: Buffer::new(),
34        }
35    }
36
37    /// Method to be called from USART or appropriate ISR.
38    pub fn isr(&mut self) -> Result<(), u8> {
39        loop {
40            let result = self.rx.read();
41            match result {
42                Ok(d) => {
43                    self.write(d)?;
44                }
45                Err(e) => {
46                    match e {
47                        Error::Other(_) => {
48                        }
49                        Error::WouldBlock => {
50                            break;
51                        }
52                    }
53                }
54            }
55        }
56        Ok(())
57    }
58
59    fn write(&mut self, octet: u8) -> Result<(), u8> {
60        self.buffer.write(octet)?;
61        Ok(())
62    }
63
64    /// Digest and process the existing ingressed buffer to
65    /// emit appropriate responses and notifications back
66    pub fn digest(&mut self) {
67        let result = self.buffer.parse();
68
69
70        if let Ok(response) = result {
71            if ! matches!(response, Response::None ) {
72                log::info!("--> {:?}", response);
73            }
74            match response {
75                Response::None => {}
76                Response::Ok
77                | Response::Error
78                | Response::FirmwareInfo(..)
79                | Response::Connect(..)
80                | Response::ReadyForData
81                | Response::ReceivedDataToSend(..)
82                | Response::DataReceived(..)
83                | Response::SendOk
84                | Response::SendFail
85                | Response::WifiConnectionFailure(..)
86                | Response::IpAddress(..)
87                | Response::Resolvers(..)
88                | Response::DnsFail
89                | Response::UnlinkFail
90                | Response::IpAddresses(..) => {
91                    if let Err(response) = self.response_producer.enqueue(response) {
92                        log::error!("failed to enqueue response {:?}", response);
93                    }
94                }
95                Response::Closed(..) | Response::DataAvailable { .. } => {
96                    if let Err(response) = self.notification_producer.enqueue(response) {
97                        log::error!("failed to enqueue notification {:?}", response);
98                    }
99                }
100                Response::WifiConnected => {
101                    log::info!("wifi connected");
102                }
103                Response::WifiDisconnect => {
104                    log::info!("wifi disconnect");
105                }
106                Response::GotIp => {
107                    log::info!("wifi got ip");
108                }
109            }
110        }
111    }
112}