Struct serial_thread::SerialInterface

pub struct SerialInterface { /* private fields */ }

Implementations

impl SerialInterface

pub fn new() -> Result<Self, SerialInterfaceError>

pub fn path(self, path: String) -> Self

pub fn bauds(self, bauds: BaudRate) -> Self

pub fn char_size(self, size: CharSize) -> Self

pub fn parity(self, parity: Parity) -> Self

pub fn stop_bits(self, stop_bits: StopBits) -> Self

pub fn flow_control(self, flow_control: FlowControl) -> Self

pub fn mode(self, mode: Mode) -> Result<Self, SerialInterfaceError>

pub fn modbus_id(self, modbus_id: u8) -> Self

pub fn silence(self, silence: Duration) -> Self

pub fn receiver(self, receiver: Receiver<SerialMessage>) -> Self

pub fn sender(self, sender: Sender<SerialMessage>) -> Self

pub fn set_mode(&mut self, m: Mode) -> Result<(), SerialInterfaceError>

pub fn get_mode(&self) -> &Mode

pub fn get_state(&self) -> &Status

pub fn list_ports() -> Result<Vec<String>, SerialInterfaceError>

pub fn open(&mut self) -> Result<(), SerialInterfaceError>

Open the serial port.

pub fn close(&mut self) -> Result<(), SerialInterfaceError>

Close the serial port.

pub async fn listen(&mut self) -> Result<Option<Mode>, SerialInterfaceError>

Sniffing feature: listen on serial line and send a SerialMessage::Receive() via mpsc channel for every serial request received, for every loop iteration, check if a SerialMessage is arrived via mpsc channel. If receive a SerialMessage::Send(), pause listen in order to send message then resume listening. Stop listening if receive SerialMessage::SetMode(Stop). Almost SerialMessage are handled silently by self.read_message().

pub async fn write_read( &mut self, data: Vec<u8>, timeout: &Duration ) -> Result<Option<SerialMessage>, SerialInterfaceError>

Master feature: write a request, then wait for response, when response received, stop listening. Returns early if receive SerialMessage::SetMode(Mode::Stop)). Does not accept SerialMessage::Send() as we already waiting for a response. Almost SerialMessage are handled silently by self.read_message().

pub async fn wait_for_request( &mut self ) -> Result<Option<SerialMessage>, SerialInterfaceError>

Slave feature: listen the line until request receive, then stop listening. Returns early if receive SerialMessage::SetMode(Mode::Stop) or SerialMessage::Send(). Almost SerialMessage are handled silently by self.read_message().

pub async fn start(&mut self)

Main loop