Struct Packet

pub struct Packet {
    pub header: Header,
    pub command: u16,
    pub frame_count: u8,
    pub frame_data: [u8; 508],
}

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

Packets are used to transmit larger amount of information (up to 508 bytes of payload) relying on the fact that both sides of the communication know how that payload is structured and how to extract the information out of it.

The “identity” of Packet values

As described in the corresponding section of the Header struct VBus data types use some of their fields as part of their “identity”. In addition to the fields used by the Header type the Packet type also respects the command field. That means that two Packet with differing timestamp, frame_count and frame_data fields are still considered “identical”, if the other fields match.

The payload of Packet values

The VBus Protocol Specification describes that all the fields used for the Packet’s “identity” can also be used to determine the structure of the payload contained in the frame_data field. The Specification type can be used to decode the payload information.

Fields

header: Header

The shared Header of all VBus protocol types.

command: u16

The command of this Packet.

frame_count: u8

The number of 4-byte frames attached to this Packet.

frame_data: [u8; 508]

The actual data from the frames attached to this Packet.

Implementations

impl Packet

pub fn valid_frame_data_len(&self) -> usize

Return the length of the valid area of the frame_data.

Examples

use resol_vbus::{Header, Packet};
use resol_vbus::utils::utc_timestamp;

let packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!(100, packet.valid_frame_data_len());

pub fn valid_frame_data(&self) -> &[u8]

Return the valid area of the frame_data immutably.

Examples

use resol_vbus::{Header, Packet};
use resol_vbus::utils::utc_timestamp;

let packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!(508, packet.frame_data.len());
assert_eq!(100, packet.valid_frame_data().len());

pub fn valid_frame_data_mut(&mut self) -> &mut [u8]

Return the valid area of the frame_data mutably.

Examples

use resol_vbus::{Header, Packet};
use resol_vbus::utils::utc_timestamp;

let mut packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!(508, packet.frame_data.len());
assert_eq!(100, packet.valid_frame_data_mut().len());

pub fn packet_id(&self) -> PacketId

Returns identification information about this Packet.

The result contains all fields that count towards the “identity” of the Packet with the exception of the protocol_version (since it must be 1.x to be a Packet anyway):

• channel
• destination_address
• source_address
• command

Examples

use resol_vbus::{Header, Packet, PacketId};
use resol_vbus::utils::utc_timestamp;

let packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!(PacketId(0x11, 0x1213, 0x1415, 0x1718), packet.packet_id());

pub fn id_string(&self) -> String

Creates an identification string for this Packet.

The string contains all fields that count towards the “identity” of the Packet:

• channel
• destination_address
• source_address
• protocol_version
• command

Examples

use resol_vbus::{Header, Packet};
use resol_vbus::utils::utc_timestamp;

let packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!("11_1213_1415_16_1718", packet.id_string());

Trait Implementations

impl AsRef<Header> for Packet

fn as_ref(&self) -> &Header

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Packet

fn clone(&self) -> Packet

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Packet

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

Formats the value using the given formatter.

impl From<Packet> for Data

fn from(packet: Packet) -> Data

Converts to this type from the input type.

impl IdHash for Packet

fn id_hash<H>(&self, h: &mut H)

where H: Hasher,

Returns an identification hash for this Packet.

The hash contains all fields that count towards the “identity” of the Packet:

• channel
• destination_address
• source_address
• protocol_version
• command

Examples

use resol_vbus::{Header, Packet, id_hash};
use resol_vbus::utils::utc_timestamp;

let packet = Packet {
    header: Header {
        timestamp: utc_timestamp(1485688933),
        channel: 0x11,
        destination_address: 0x1213,
        source_address: 0x1415,
        protocol_version: 0x16,
    },
    command: 0x1718,
    frame_count: 0x19,
    frame_data: [0u8; 508],
};

assert_eq!(2215810099849021132, id_hash(&packet));

impl ToPacketId for Packet

fn to_packet_id(&self) -> Result<PacketId, Error>

Get the PacketId for a given value.