Struct BACnetClient 

pub struct BACnetClient<T: TransportPort> { /* private fields */ }

BACnet client with low-level and high-level request APIs.

Implementations

impl BACnetClient<BipTransport>

pub fn bip_builder() -> BipClientBuilder

Create a BIP-specific builder with interface/port/broadcast fields.

pub fn builder() -> BipClientBuilder

pub async fn read_bdt(&self, target: &[u8]) -> Result<Vec<BdtEntry>, Error>

Read the Broadcast Distribution Table from a BBMD.

pub async fn write_bdt( &self, target: &[u8], entries: &[BdtEntry], ) -> Result<BvlcResultCode, Error>

Write the Broadcast Distribution Table to a BBMD.

pub async fn read_fdt(&self, target: &[u8]) -> Result<Vec<FdtEntryWire>, Error>

Read the Foreign Device Table from a BBMD.

pub async fn delete_fdt_entry( &self, target: &[u8], ip: [u8; 4], port: u16, ) -> Result<BvlcResultCode, Error>

Delete a Foreign Device Table entry on a BBMD.

pub async fn register_foreign_device_bvlc( &self, target: &[u8], ttl: u16, ) -> Result<BvlcResultCode, Error>

Register as a foreign device with a BBMD and return the result code.

impl<T: TransportPort + 'static> BACnetClient<T>

pub fn generic_builder() -> ClientBuilder<T>

Create a generic builder that accepts a pre-built transport.

pub async fn start(config: ClientConfig, transport: T) -> Result<Self, Error>

Start the client: bind transport, start network layer, spawn dispatch.

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

Get the client’s local MAC address.

pub async fn confirmed_request( &self, destination_mac: &[u8], service_choice: ConfirmedServiceChoice, service_data: &[u8], ) -> Result<Bytes, Error>

Send a confirmed request and wait for the response.

Returns the service response data (empty for SimpleAck). Automatically uses segmented transfer when the payload exceeds the remote device’s max APDU length.

pub async fn confirmed_request_routed( &self, router_mac: &[u8], dest_network: u16, dest_mac: &[u8], service_choice: ConfirmedServiceChoice, service_data: &[u8], ) -> Result<Bytes, Error>

Send a confirmed request routed through a BACnet router.

The NPDU is sent as a unicast to router_mac with DNET/DADR set so the router forwards it to dest_network/dest_mac.

pub async fn unconfirmed_request( &self, destination_mac: &[u8], service_choice: UnconfirmedServiceChoice, service_data: &[u8], ) -> Result<(), Error>

Send an unconfirmed request (fire-and-forget) to a specific destination.

pub async fn broadcast_unconfirmed( &self, service_choice: UnconfirmedServiceChoice, service_data: &[u8], ) -> Result<(), Error>

Broadcast an unconfirmed request on the local network.

pub async fn broadcast_global_unconfirmed( &self, service_choice: UnconfirmedServiceChoice, service_data: &[u8], ) -> Result<(), Error>

Broadcast an unconfirmed request globally (DNET=0xFFFF).

pub async fn broadcast_network_unconfirmed( &self, service_choice: UnconfirmedServiceChoice, service_data: &[u8], dest_network: u16, ) -> Result<(), Error>

Broadcast an unconfirmed request to a specific remote network.

pub async fn read_property( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, ) -> Result<ReadPropertyACK, Error>

Read a property from a remote device.

pub async fn read_property_from_device( &self, device_instance: u32, object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, ) -> Result<ReadPropertyACK, Error>

Read a property from a discovered device, auto-routing if needed.

pub async fn read_property_routed( &self, router_mac: &[u8], dest_network: u16, dest_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, ) -> Result<ReadPropertyACK, Error>

Read a property from a device on a remote BACnet network via a router.

pub async fn write_property( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, property_value: Vec<u8>, priority: Option<u8>, ) -> Result<(), Error>

Write a property on a remote device.

pub async fn read_property_multiple( &self, destination_mac: &[u8], specs: Vec<ReadAccessSpecification>, ) -> Result<ReadPropertyMultipleACK, Error>

Read multiple properties from one or more objects on a remote device.

pub async fn write_property_multiple( &self, destination_mac: &[u8], specs: Vec<WriteAccessSpecification>, ) -> Result<(), Error>

Write multiple properties on one or more objects on a remote device.

pub async fn read_property_multiple_from_device( &self, device_instance: u32, specs: Vec<ReadAccessSpecification>, ) -> Result<ReadPropertyMultipleACK, Error>

Read multiple properties from a discovered device, auto-routing if needed.

pub async fn write_property_to_device( &self, device_instance: u32, object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, property_value: Vec<u8>, priority: Option<u8>, ) -> Result<(), Error>

Write a property on a discovered device, auto-routing if needed.

pub async fn write_property_multiple_to_device( &self, device_instance: u32, specs: Vec<WriteAccessSpecification>, ) -> Result<(), Error>

Write multiple properties on a discovered device, auto-routing if needed.

pub async fn read_property_from_devices( &self, requests: Vec<DeviceReadRequest>, max_concurrent: Option<usize>, ) -> Vec<DeviceReadResult>

Read a property from multiple discovered devices concurrently.

All requests are dispatched concurrently (up to max_concurrent, default 32) and results are returned in completion order. Each device is resolved from the device table and auto-routed if behind a router.

pub async fn read_property_multiple_from_devices( &self, requests: Vec<DeviceRpmRequest>, max_concurrent: Option<usize>, ) -> Vec<DeviceRpmResult>

Read multiple properties from multiple devices concurrently (RPM batch).

Sends an RPM to each device concurrently. This is the most efficient way to poll many properties across many devices — RPM batches within a single device, and this method batches across devices.

pub async fn write_property_to_devices( &self, requests: Vec<DeviceWriteRequest>, max_concurrent: Option<usize>, ) -> Vec<DeviceWriteResult>

Write a property on multiple devices concurrently.

All writes are dispatched concurrently (up to max_concurrent, default 32). Results are returned in completion order.

pub async fn who_is( &self, low_limit: Option<u32>, high_limit: Option<u32>, ) -> Result<(), Error>

Send a WhoIs broadcast to discover devices.

pub async fn who_is_directed( &self, destination_mac: &[u8], low_limit: Option<u32>, high_limit: Option<u32>, ) -> Result<(), Error>

Send a directed (unicast) WhoIs to a specific device.

pub async fn who_is_network( &self, dest_network: u16, low_limit: Option<u32>, high_limit: Option<u32>, ) -> Result<(), Error>

Send a WhoIs broadcast to a specific remote network.

pub async fn who_has( &self, object: WhoHasObject, low_limit: Option<u32>, high_limit: Option<u32>, ) -> Result<(), Error>

Send a WhoHas broadcast to find an object by identifier or name.

pub async fn subscribe_cov( &self, destination_mac: &[u8], subscriber_process_identifier: u32, monitored_object_identifier: ObjectIdentifier, confirmed: bool, lifetime: Option<u32>, ) -> Result<(), Error>

Subscribe to COV notifications for an object on a remote device.

pub async fn unsubscribe_cov( &self, destination_mac: &[u8], subscriber_process_identifier: u32, monitored_object_identifier: ObjectIdentifier, ) -> Result<(), Error>

Cancel a COV subscription on a remote device.

pub async fn delete_object( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, ) -> Result<(), Error>

Delete an object on a remote device.

pub async fn create_object( &self, destination_mac: &[u8], object_specifier: ObjectSpecifier, initial_values: Vec<BACnetPropertyValue>, ) -> Result<Bytes, Error>

Create an object on a remote device.

pub async fn device_communication_control( &self, destination_mac: &[u8], enable_disable: EnableDisable, time_duration: Option<u16>, password: Option<String>, ) -> Result<(), Error>

Send DeviceCommunicationControl to a remote device.

pub async fn reinitialize_device( &self, destination_mac: &[u8], reinitialized_state: ReinitializedState, password: Option<String>, ) -> Result<(), Error>

Send ReinitializeDevice to a remote device.

pub async fn get_event_information( &self, destination_mac: &[u8], last_received_object_identifier: Option<ObjectIdentifier>, ) -> Result<Bytes, Error>

Get event information from a remote device.

pub async fn acknowledge_alarm( &self, destination_mac: &[u8], acknowledging_process_identifier: u32, event_object_identifier: ObjectIdentifier, event_state_acknowledged: u32, acknowledgment_source: &str, ) -> Result<(), Error>

Acknowledge an alarm on a remote device.

pub async fn read_range( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, range: Option<RangeSpec>, ) -> Result<ReadRangeAck, Error>

Read a range of items from a list or log-buffer property.

pub async fn atomic_read_file( &self, destination_mac: &[u8], file_identifier: ObjectIdentifier, access: FileAccessMethod, ) -> Result<Bytes, Error>

Read file data from a remote device (stream or record access).

pub async fn atomic_write_file( &self, destination_mac: &[u8], file_identifier: ObjectIdentifier, access: FileWriteAccessMethod, ) -> Result<Bytes, Error>

Write file data to a remote device (stream or record access).

pub async fn add_list_element( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, list_of_elements: Vec<u8>, ) -> Result<(), Error>

Add elements to a list property on a remote device.

pub async fn remove_list_element( &self, destination_mac: &[u8], object_identifier: ObjectIdentifier, property_identifier: PropertyIdentifier, property_array_index: Option<u32>, list_of_elements: Vec<u8>, ) -> Result<(), Error>

Remove elements from a list property on a remote device.

pub async fn time_synchronization( &self, destination_mac: &[u8], date: Date, time: Time, ) -> Result<(), Error>

Send a TimeSynchronization request (unconfirmed, no response expected).

pub async fn utc_time_synchronization( &self, destination_mac: &[u8], date: Date, time: Time, ) -> Result<(), Error>

Send a UTCTimeSynchronization request (unconfirmed, no response expected).

pub fn cov_notifications(&self) -> Receiver<COVNotificationRequest>

Get a receiver for incoming COV notifications. Each call returns a new independent receiver.

pub async fn discovered_devices(&self) -> Vec<DiscoveredDevice>

Get a snapshot of all discovered devices.

pub async fn get_device(&self, instance: u32) -> Option<DiscoveredDevice>

Look up a discovered device by instance number.

pub async fn clear_devices(&self)

Clear the discovered devices table.

pub async fn add_device(&self, instance: u32, mac: &[u8]) -> Result<(), Error>

Manually register a device in the device table.

Useful for adding known devices without requiring WhoIs/IAm exchange. Sets default values for max_apdu_length (1476), segmentation (NONE), and vendor_id (0) since these are unknown without IAm.

pub async fn stop(&mut self) -> Result<(), Error>

Stop the client, aborting the dispatch task.