Struct DeviceDiscovery

pub struct DeviceDiscovery { /* private fields */ }

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

All VBus-over-TCP devices listen for UDPv4 broadcast messages on port 7053. If such a message with the correct payload is received, the device sends a unicast message back to the sender of the broadcast to identify itself.

The DeviceDiscovery type allows to send such broadcasts and collect all associated replies.

Implementations

impl DeviceDiscovery

pub fn new() -> DeviceDiscovery

Create a new DeviceDiscovery instance using default values.

Examples

use async_resol_vbus::DeviceDiscovery;

let discovery = DeviceDiscovery::new();
let addresses = discovery.discover_device_addresses().await?;

Examples found in repository

examples/discover.rs (line 15)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        let mut discovery = DeviceDiscovery::new();
        // discovery.set_broadcast_addr("192.168.15.255:7053".parse().unwrap());
        discovery.set_fetch_port(3000);

        let mut known_devices = Vec::<DeviceInformation>::new();
        loop {
            println!("---- Discovering... ----");

            let mut found_devices = discovery.discover_devices().await?;
            found_devices.sort_by(|l, r| compare_devices(l, r));

            known_devices.sort_by(|l, r| compare_devices(l, r));

            for found_device in found_devices.iter() {
                let is_known_device = known_devices
                    .iter()
                    .any(|known_device| known_device.address == found_device.address);

                if !is_known_device {
                    let name = match &found_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("FOUND: {} {}", found_device.address, name);
                    known_devices.push(found_device.clone());
                }
            }

            let mut lost_device_addresses = Vec::new();

            for known_device in known_devices.iter() {
                let is_found_device = found_devices
                    .iter()
                    .any(|found_device| known_device.address == found_device.address);

                if !is_found_device {
                    let name = match &known_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("LOST:  {} {}", known_device.address, name);
                    lost_device_addresses.push(known_device.address);
                }
            }

            for lost_device_address in lost_device_addresses {
                let pos = known_devices
                    .iter()
                    .position(|known_device| known_device.address == lost_device_address);

                if let Some(idx) = pos {
                    known_devices.remove(idx);
                }
            }

            async_std::task::sleep(std::time::Duration::from_secs(10)).await;
        }
    })
}

pub fn set_broadcast_addr(&mut self, addr: SocketAddr)

Set the broadcast address.

pub fn set_rounds(&mut self, rounds: u8)

Set the number of discovery rounds.

pub fn set_broadcast_timeout(&mut self, timeout: Duration)

Set the timeout used to wait for replies after each round’s broadcast.

pub fn set_fetch_port(&mut self, port: u16)

Set the port number used for fetching the device information.

Examples found in repository

examples/discover.rs (line 17)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        let mut discovery = DeviceDiscovery::new();
        // discovery.set_broadcast_addr("192.168.15.255:7053".parse().unwrap());
        discovery.set_fetch_port(3000);

        let mut known_devices = Vec::<DeviceInformation>::new();
        loop {
            println!("---- Discovering... ----");

            let mut found_devices = discovery.discover_devices().await?;
            found_devices.sort_by(|l, r| compare_devices(l, r));

            known_devices.sort_by(|l, r| compare_devices(l, r));

            for found_device in found_devices.iter() {
                let is_known_device = known_devices
                    .iter()
                    .any(|known_device| known_device.address == found_device.address);

                if !is_known_device {
                    let name = match &found_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("FOUND: {} {}", found_device.address, name);
                    known_devices.push(found_device.clone());
                }
            }

            let mut lost_device_addresses = Vec::new();

            for known_device in known_devices.iter() {
                let is_found_device = found_devices
                    .iter()
                    .any(|found_device| known_device.address == found_device.address);

                if !is_found_device {
                    let name = match &known_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("LOST:  {} {}", known_device.address, name);
                    lost_device_addresses.push(known_device.address);
                }
            }

            for lost_device_address in lost_device_addresses {
                let pos = known_devices
                    .iter()
                    .position(|known_device| known_device.address == lost_device_address);

                if let Some(idx) = pos {
                    known_devices.remove(idx);
                }
            }

            async_std::task::sleep(std::time::Duration::from_secs(10)).await;
        }
    })
}

pub fn set_fetch_timeout(&mut self, timeout: Duration)

Set the timeout used for fetching the device information.

pub async fn discover_devices(&self) -> Result<Vec<DeviceInformation>>

Discover all VBus-over-TCP devices and return their device information.

Examples

use async_resol_vbus::DeviceDiscovery;

let discovery = DeviceDiscovery::new();
let devices = discovery.discover_devices().await?;

Examples found in repository

examples/discover.rs (line 23)

fn main() -> Result<()> {
    async_std::task::block_on(async {
        let mut discovery = DeviceDiscovery::new();
        // discovery.set_broadcast_addr("192.168.15.255:7053".parse().unwrap());
        discovery.set_fetch_port(3000);

        let mut known_devices = Vec::<DeviceInformation>::new();
        loop {
            println!("---- Discovering... ----");

            let mut found_devices = discovery.discover_devices().await?;
            found_devices.sort_by(|l, r| compare_devices(l, r));

            known_devices.sort_by(|l, r| compare_devices(l, r));

            for found_device in found_devices.iter() {
                let is_known_device = known_devices
                    .iter()
                    .any(|known_device| known_device.address == found_device.address);

                if !is_known_device {
                    let name = match &found_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("FOUND: {} {}", found_device.address, name);
                    known_devices.push(found_device.clone());
                }
            }

            let mut lost_device_addresses = Vec::new();

            for known_device in known_devices.iter() {
                let is_found_device = found_devices
                    .iter()
                    .any(|found_device| known_device.address == found_device.address);

                if !is_found_device {
                    let name = match &known_device.name {
                        Some(name) => name.as_str(),
                        None => "???",
                    };

                    println!("LOST:  {} {}", known_device.address, name);
                    lost_device_addresses.push(known_device.address);
                }
            }

            for lost_device_address in lost_device_addresses {
                let pos = known_devices
                    .iter()
                    .position(|known_device| known_device.address == lost_device_address);

                if let Some(idx) = pos {
                    known_devices.remove(idx);
                }
            }

            async_std::task::sleep(std::time::Duration::from_secs(10)).await;
        }
    })
}

pub async fn discover_device_addresses(&self) -> Result<Vec<SocketAddr>>

Discover all VBus-over-TCP devices and return their addresses.

Examples

use async_resol_vbus::DeviceDiscovery;

let discovery = DeviceDiscovery::new();
let addresses = discovery.discover_device_addresses().await?;

Trait Implementations

impl Debug for DeviceDiscovery

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

Formats the value using the given formatter.

impl Default for DeviceDiscovery

fn default() -> DeviceDiscovery

Returns the “default value” for a type.