Optimizations

Author: jscott3201

crates/bacnet-client/src/client.rs

@@ -1912,6 +1912,31 @@ impl<T: TransportPort + 'static> BACnetClient<T> {
         self.device_table.lock().await.clear();
     }
 
+    /// 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 add_device(&self, instance: u32, mac: &[u8]) -> Result<(), Error> {
+        let oid = bacnet_types::primitives::ObjectIdentifier::new(
+            bacnet_types::enums::ObjectType::DEVICE,
+            instance,
+        )?;
+        let device = DiscoveredDevice {
+            object_identifier: oid,
+            mac_address: MacAddr::from_slice(mac),
+            max_apdu_length: 1476,
+            segmentation_supported: bacnet_types::enums::Segmentation::NONE,
+            max_segments_accepted: None,
+            vendor_id: 0,
+            last_seen: std::time::Instant::now(),
+            source_network: None,
+            source_address: None,
+        };
+        self.device_table.lock().await.upsert(device);
+        Ok(())
+    }
+
     /// Stop the client, aborting the dispatch task.
     pub async fn stop(&mut self) -> Result<(), Error> {
         if let Some(task) = self.dispatch_task.take() {

crates/bacnet-gateway/src/api/devices.rs

@@ -19,6 +19,9 @@ pub struct DiscoverRequest {
     pub low_instance: Option<u32>,
     pub high_instance: Option<u32>,
     pub timeout_seconds: Option<u64>,
+    /// Target address for unicast discovery (e.g., "192.168.1.100:47808").
+    /// If omitted, sends a broadcast WhoIs.
+    pub target: Option<String>,
 }
 
 pub async fn discover_devices(
@@ -47,16 +50,57 @@ pub async fn discover_devices(
         .unwrap_or(3)
         .min(MAX_DISCOVER_TIMEOUT_SECS);
 
-    if let Err(e) = client.who_is(low, high).await {
-        let (status, err) = ApiError::from_bacnet_error(&e);
-        return (status, Json(err)).into_response();
+    let target = body.as_ref().and_then(|b| b.target.as_ref());
+    match target {
+        Some(t) => {
+            let addr: std::net::SocketAddrV4 = match t.parse() {
+                Ok(a) => a,
+                Err(e) => {
+                    return ApiError::bad_request(format!("invalid target address: {e}"))
+                        .into_response()
+                }
+            };
+            let mac = crate::parse::socket_addr_to_mac(addr);
+            if let Err(e) = client.who_is_directed(&mac, low, high).await {
+                let (status, err) = ApiError::from_bacnet_error(&e);
+                return (status, Json(err)).into_response();
+            }
+        }
+        None => {
+            if let Err(e) = client.who_is(low, high).await {
+                let (status, err) = ApiError::from_bacnet_error(&e);
+                return (status, Json(err)).into_response();
+            }
+        }
     }
 
     tokio::time::sleep(std::time::Duration::from_secs(timeout)).await;
 
     list_known_devices_inner(&state).await.into_response()
 }
 
+/// POST /api/v1/devices
+#[derive(Debug, Deserialize)]
+pub struct RegisterDeviceRequest {
+    pub instance: u32,
+    pub address: String,
+}
+
+pub async fn register_device(
+    State(state): State<GatewayState>,
+    Json(req): Json<RegisterDeviceRequest>,
+) -> impl IntoResponse {
+    match state.add_device_manual(req.instance, &req.address).await {
+        Ok(()) => Json(serde_json::json!({
+            "status": "registered",
+            "instance": req.instance,
+            "address": req.address,
+        }))
+        .into_response(),
+        Err(msg) => ApiError::bad_request(msg).into_response(),
+    }
+}
+
 /// GET /api/v1/devices
 pub async fn list_devices(State(state): State<GatewayState>) -> impl IntoResponse {
     list_known_devices_inner(&state).await

crates/bacnet-gateway/src/api/mod.rs

@@ -38,7 +38,10 @@ pub fn api_router(state: GatewayState, auth: Option<Box<dyn Authenticator>>) ->
             get(objects::get_object_property).put(objects::put_object_property),
         )
         // Device discovery.
-        .route("/devices", get(devices::list_devices))
+        .route(
+            "/devices",
+            get(devices::list_devices).post(devices::register_device),
+        )
         .route("/devices/discover", post(devices::discover_devices))
         .route("/devices/{instance}", get(devices::get_device_info))
         // Remote property access.

crates/bacnet-gateway/src/api/objects.rs

@@ -12,7 +12,8 @@ use crate::state::GatewayState;
 
 use super::types::{
     json_to_property_value, object_type_name, parse_object_specifier, parse_object_type,
-    parse_property_name, property_name, property_value_to_json, ApiError, WritePropertyRequest,
+    parse_property_name, property_name, property_value_to_json,
+    property_value_to_json_with_context, ApiError, WritePropertyRequest,
 };
 
 #[derive(Debug, Deserialize)]
@@ -87,7 +88,7 @@ pub async fn get_object(
             obj.read_property(prop, None).ok().map(|val| {
                 serde_json::json!({
                     "property": property_name(prop),
-                    "value": property_value_to_json(&val),
+                    "value": property_value_to_json_with_context(&val, prop),
                 })
             })
         })
@@ -135,7 +136,7 @@ pub async fn get_object_property(
     match obj.read_property(property, array_index) {
         Ok(val) => Json(serde_json::json!({
             "property": property_name(property),
-            "value": property_value_to_json(&val),
+            "value": property_value_to_json_with_context(&val, property),
         }))
         .into_response(),
         Err(e) => {

crates/bacnet-gateway/src/api/properties.rs

@@ -10,8 +10,8 @@ use bacnet_types::primitives::ObjectIdentifier;
 use crate::state::GatewayState;
 
 use super::types::{
-    decode_raw_property_to_json, json_to_property_value, object_type_name, parse_object_specifier,
-    parse_property_name, property_name, ApiError, WritePropertyRequest,
+    decode_raw_property_to_json_with_context, json_to_property_value, object_type_name,
+    parse_object_specifier, parse_property_name, property_name, ApiError, WritePropertyRequest,
 };
 
 /// GET /api/v1/devices/{instance}/objects/{specifier}/properties/{property}
@@ -61,7 +61,7 @@ pub async fn read_remote_property(
             "device": instance,
             "object": format!("{}:{}", object_type_name(obj_type), obj_instance),
             "property": property_name(property),
-            "value": decode_raw_property_to_json(&ack.property_value),
+            "value": decode_raw_property_to_json_with_context(&ack.property_value, property),
         }))
         .into_response(),
         Err(e) => {

crates/bacnet-gateway/src/builder.rs

@@ -11,6 +11,7 @@ use bacnet_transport::bip::BipTransport;
 use bacnet_types::error::Error;
 
 use crate::config::GatewayConfig;
+use crate::parse::{construct_object, parse_object_type};
 use crate::state::GatewayState;
 
 /// Builder for constructing a fully wired Gateway.
@@ -39,6 +40,27 @@ impl GatewayBuilder {
         })?;
         db.add(Box::new(device))?;
 
+        // Pre-populate local objects from config.
+        for obj_cfg in &self.config.objects {
+            let obj_type = parse_object_type(&obj_cfg.object_type)
+                .map_err(|e| Error::Encoding(format!("object config: {e}")))?;
+            let obj = construct_object(
+                obj_type,
+                obj_cfg.instance,
+                &obj_cfg.name,
+                obj_cfg.number_of_states,
+            )
+            .map_err(|e| Error::Encoding(format!("object config: {e}")))?;
+            db.add(obj)
+                .map_err(|e| Error::Encoding(format!("object config: {e}")))?;
+            tracing::info!(
+                "Pre-populated object {}:{} ({})",
+                obj_cfg.object_type,
+                obj_cfg.instance,
+                obj_cfg.name
+            );
+        }
+
         // Determine BIP settings (required for now).
         let bip = self.config.transports.bip.as_ref().ok_or_else(|| {
             Error::Encoding("[transports.bip] is required for the gateway".to_string())
@@ -53,23 +75,69 @@ impl GatewayBuilder {
             .parse()
             .map_err(|e| Error::Encoding(format!("invalid BIP broadcast: {e}")))?;
 
-        // Start server on the configured BIP port.
-        let server = BACnetServer::bip_builder()
-            .interface(interface)
-            .port(bip.port)
-            .broadcast_address(broadcast)
+        // Parse foreign device config once (used for both server and client transports).
+        let fd_config = if let Some(fd) = &self.config.foreign_device {
+            let addr: std::net::SocketAddrV4 = fd.bbmd.parse().map_err(|e| {
+                Error::Encoding(format!("invalid foreign_device.bbmd '{}': {e}", fd.bbmd))
+            })?;
+            Some(bacnet_transport::bip::ForeignDeviceConfig {
+                bbmd_ip: *addr.ip(),
+                bbmd_port: addr.port(),
+                ttl: fd.ttl,
+            })
+        } else {
+            None
+        };
+
+        // Create and configure BIP transport for the server.
+        let mut server_transport = BipTransport::new(interface, bip.port, broadcast);
+
+        if let Some(ref fdc) = fd_config {
+            server_transport.register_as_foreign_device(fdc.clone());
+            tracing::info!(
+                "Registered as foreign device with BBMD {}:{}",
+                fdc.bbmd_ip,
+                fdc.bbmd_port
+            );
+        }
+
+        if let Some(bbmd_cfg) = &self.config.bbmd {
+            if bbmd_cfg.enabled {
+                let mut bdt_entries = Vec::new();
+                for entry_str in &bbmd_cfg.bdt {
+                    let addr: std::net::SocketAddrV4 = entry_str.parse().map_err(|e| {
+                        Error::Encoding(format!("invalid BDT entry '{entry_str}': {e}"))
+                    })?;
+                    bdt_entries.push(bacnet_transport::bbmd::BdtEntry {
+                        ip: addr.ip().octets(),
+                        port: addr.port(),
+                        broadcast_mask: [0xff, 0xff, 0xff, 0xff],
+                    });
+                }
+                server_transport.enable_bbmd(bdt_entries);
+                tracing::info!("BBMD enabled with {} BDT entries", bbmd_cfg.bdt.len());
+            }
+        }
+
+        // Start server with the pre-configured transport.
+        let server = BACnetServer::generic_builder()
+            .transport(server_transport)
             .database(db)
+            .vendor_id(self.config.device.vendor_id)
             .build()
             .await?;
 
         let server_mac = server.local_mac().to_vec();
         let db = server.database().clone();
 
-        // Start client on an ephemeral port.
-        let client = BACnetClient::bip_builder()
-            .interface(interface)
-            .port(0)
-            .broadcast_address(broadcast)
+        // Create client transport (also needs foreign device config for broadcast routing).
+        let mut client_transport = BipTransport::new(interface, 0, broadcast);
+        if let Some(ref fdc) = fd_config {
+            client_transport.register_as_foreign_device(fdc.clone());
+        }
+
+        let client = BACnetClient::generic_builder()
+            .transport(client_transport)
             .apdu_timeout_ms(6000)
             .build()
             .await?;

crates/bacnet-gateway/src/config.rs

@@ -191,6 +191,8 @@ pub struct ObjectConfig {
     pub name: String,
     /// Engineering units (optional).
     pub units: Option<String>,
+    /// Number of states for multi-state objects (default: 2).
+    pub number_of_states: Option<u32>,
 }
 
 /// Configuration validation error.