Struct TcpClientHandshake

pub struct TcpClientHandshake { /* private fields */ }

Handles the client-side of the VBus-over-TCP handshake.

Examples

use async_std::net::{SocketAddr, TcpStream};

use async_resol_vbus::TcpClientHandshake;

let address = "192.168.5.217:7053".parse::<SocketAddr>()?;
let stream = TcpStream::connect(address).await?;
let mut hs = TcpClientHandshake::start(stream).await?;
hs.send_pass_command("vbus").await?;
let stream = hs.send_data_command().await?;
// ...

Implementations

impl TcpClientHandshake

pub async fn start(stream: TcpStream) -> Result<TcpClientHandshake>

Start the handshake by waiting for the initial greeting reply from the service.

Examples found in repository

examples/live_data_recorder.rs (line 20)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        // Create an recording file and hand it to a `RecordingWriter`
        let file = File::create("test.vbus")?;
        let mut rw = RecordingWriter::new(file);

        // Parse the address of the DL2 to connect to
        let addr = "192.168.5.217:7053".parse::<SocketAddr>()?;

        let stream = TcpStream::connect(addr).await?;

        let mut hs = TcpClientHandshake::start(stream).await?;
        hs.send_pass_command("vbus").await?;
        let stream = hs.send_data_command().await?;

        let (reader, writer) = (&stream, &stream);

        let mut stream = LiveDataStream::new(reader, writer, 0, 0x0020);

        while let Some(data) = stream.receive_any_data(60000).await? {
            println!("{}", data.id_string());

            // Add `Data` value into `DataSet` to be stored
            let mut data_set = DataSet::new();
            data_set.timestamp = data.as_ref().timestamp;
            data_set.add_data(data);

            // Write the `DataSet` into the `RecordingWriter` for permanent storage
            rw.write_data_set(&data_set)
                .expect("Unable to write data set");
        }

        Ok(())
    })
}

pub fn into_inner(self) -> TcpStream

Consume self and return the underlying TcpStream.

pub async fn send_connect_command(&mut self, via_tag: &str) -> Result<()>

Send the CONNECT command and wait for the reply.

pub async fn send_pass_command(&mut self, password: &str) -> Result<()>

Send the PASS command and wait for the reply.

Examples found in repository

examples/live_data_recorder.rs (line 21)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        // Create an recording file and hand it to a `RecordingWriter`
        let file = File::create("test.vbus")?;
        let mut rw = RecordingWriter::new(file);

        // Parse the address of the DL2 to connect to
        let addr = "192.168.5.217:7053".parse::<SocketAddr>()?;

        let stream = TcpStream::connect(addr).await?;

        let mut hs = TcpClientHandshake::start(stream).await?;
        hs.send_pass_command("vbus").await?;
        let stream = hs.send_data_command().await?;

        let (reader, writer) = (&stream, &stream);

        let mut stream = LiveDataStream::new(reader, writer, 0, 0x0020);

        while let Some(data) = stream.receive_any_data(60000).await? {
            println!("{}", data.id_string());

            // Add `Data` value into `DataSet` to be stored
            let mut data_set = DataSet::new();
            data_set.timestamp = data.as_ref().timestamp;
            data_set.add_data(data);

            // Write the `DataSet` into the `RecordingWriter` for permanent storage
            rw.write_data_set(&data_set)
                .expect("Unable to write data set");
        }

        Ok(())
    })
}

pub async fn send_channel_command(&mut self, channel: u8) -> Result<()>

Send the CHANNEL command and wait for the reply.

pub async fn send_data_command(self) -> Result<TcpStream>

Send the DATA command and wait for the reply.

This function returns the underlying TcpStream since the handshake is complete after sending this command.

Examples found in repository

examples/live_data_recorder.rs (line 22)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        // Create an recording file and hand it to a `RecordingWriter`
        let file = File::create("test.vbus")?;
        let mut rw = RecordingWriter::new(file);

        // Parse the address of the DL2 to connect to
        let addr = "192.168.5.217:7053".parse::<SocketAddr>()?;

        let stream = TcpStream::connect(addr).await?;

        let mut hs = TcpClientHandshake::start(stream).await?;
        hs.send_pass_command("vbus").await?;
        let stream = hs.send_data_command().await?;

        let (reader, writer) = (&stream, &stream);

        let mut stream = LiveDataStream::new(reader, writer, 0, 0x0020);

        while let Some(data) = stream.receive_any_data(60000).await? {
            println!("{}", data.id_string());

            // Add `Data` value into `DataSet` to be stored
            let mut data_set = DataSet::new();
            data_set.timestamp = data.as_ref().timestamp;
            data_set.add_data(data);

            // Write the `DataSet` into the `RecordingWriter` for permanent storage
            rw.write_data_set(&data_set)
                .expect("Unable to write data set");
        }

        Ok(())
    })
}

pub async fn send_quit_command(self) -> Result<()>

Send the QUIT command and wait for the reply.

Trait Implementations

impl Debug for TcpClientHandshake

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.