Crate async_resol_vbus

async-resol-vbus.rs

A Rust library for processing RESOL VBus data asynchronously.

Features

• Allows discovery of VBus-over-TCP devices in a local network
• Connect to or provide VBus-over-TCP services

Planned, but not yet implemented features

• none (yet)

Examples

use std::fs::File;

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

use resol_vbus::{DataSet, RecordingWriter};

use async_resol_vbus::{Result, LiveDataStream, TcpClientHandshake};

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.13.45: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(())
    })
}

Modules

chrono

Chrono: Date and Time for Rust

live_data_decoder

Functions in this module can be used to decode byte slices of data conforming to the VBus protocol specification into the respective Data variants.

live_data_encoder

Functions in the module can be used to convert a Data variant into the respective live representation according to the VBus protocol specification.

recording_decoder

Functions in this module allow to decode a byte stream conforming to the VBus Recording File Format.

recording_encoder

Functions in the module can be used to convert a Data variant into the respective recorded representation according to the VBus Recording File Format.

specification

This module provides the Specification and its associated types to allow interpretation of the fields contained within the frame_data payload of Packet values.

specification_file

A module that parses the contents of a VBus Specification File Version 1 (VSF1).

utils

A module containing utitlities functions for processing VBus data.

Structs

BlobBuffer

A size-adating buffer to store bytes in. The buffer grows when data is stored into it. The contents can then be consumed which results in the buffer dropping the consumed data before new data are appended.

BlobReader

A buffering reader that allows to borrow the internal buffer.

DataSet

A DataSet contains a set of unique (non-identical) Data values.

Datagram

The Datagram type stores information according to the VBus protocol version 2.x.

DeviceDiscovery

Allows discovery of VBus-over-TCP devices in a local network.

DeviceInformation

A struct containing information about a VBus-over-TCP device.

Error

A common error type.

FileListReader

Chains multiple files together in a single Read object.

Header

All VBus data types consist of a Header element.

LiveDataBuffer

A size-adapting buffer that supports decoding VBus live data. See BlobBuffer for details.

LiveDataReader

Allows reading Data variants from a Read trait object.

LiveDataRecordingReader

A RecordingReader for type 0x88 live data recordings.

LiveDataRecordingWriter

A RecordingWriter for type 0x88 live data recordings.

LiveDataStream

A Stream/Sink wrapper for RESOL VBus Data items encoded in the live / wire representation.

LiveDataWriter

Allows writing the live represenation of Data variants to a Write trait object.

Packet

The Packet type stores information according to the VBus protocol version 1.x.

PacketFieldId

A tuple of identification information about a field in a Packet value.

PacketId

A tuple of identification information about a Packet value.

RecordingReader

Allows reading Data variants from a Read trait object.

RecordingWriter

Allows writing the recorded representation of DataSet values to a Write trait object.

Specification

The Specification type contains information about known devices and packets.

SpecificationFile

Contains the information from a VSF1 file.

TcpClientHandshake

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

TcpServerHandshake

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

Telegram

The Telegram type stores information according to the VBus protocol version 3.x.

Enums

Data

Data is a type that contains one of the supported VBus protocol data variants.

Language

Languages supported by VSF1 specification.

StreamBlobLength

Provides information whether a slice of bytes contains a valid blob of data.

Traits

IdHash

A trait to generate an identification hash for any of the VBus data types.

ToPacketFieldId

A trait to get a PacketFieldId for a given value.

ToPacketId

A trait to get a PacketId for a given value.

Functions

id_hash

Calculate the identification hash for a given VBus data value.

Type Aliases

Result

A common result type.