fixing bacnet

Author: gtfierro

buildingmotif/ingresses/bacnet.py

@@ -1,12 +1,12 @@
 # configure logging output
+import asyncio
 import logging
 import warnings
 from functools import cached_property
 from typing import Any, Dict, List, Optional, Tuple
 
 try:
     import BAC0
-    from BAC0.core.devices.Device import Device as BACnetDevice
 except ImportError:
     logging.critical(
         "Install the 'bacnet-ingress' module, e.g. 'pip install buildingmotif[bacnet-ingress]'"
@@ -23,43 +23,75 @@
 
 
 class BACnetNetwork(RecordIngressHandler):
-    def __init__(self, ip: Optional[str] = None):
+    def __init__(
+        self,
+        ip: Optional[str] = None,
+        *,
+        discover_kwargs: Optional[Dict[str, Any]] = None,
+        ping: bool = False,
+        device_kwargs: Optional[Dict[str, Any]] = None,
+    ):
         """
         Reads a BACnet network to discover the devices and objects therein
 
-        :param ip: IP/mask for the host which is canning the networks,
+        :param ip: IP/mask for the host which is scanning the network,
                     defaults to None
         :type ip: Optional[str], optional
+        :param discover_kwargs: Optional kwargs forwarded to BAC0._discover.
+        :type discover_kwargs: Optional[Dict[str, Any]]
+        :param ping: Whether to ping devices during connect; defaults to False.
+        :type ping: bool
+        :param device_kwargs: Optional kwargs forwarded to BAC0.device.
+        :type device_kwargs: Optional[Dict[str, Any]]
         """
-        # create the network object; this will handle scans
-        # Be a good net citizen: do not ping BACnet devices
-        self.network = BAC0.connect(ip=ip, ping=False)
-        # initiate discovery of BACnet networks
-        self.network.discover()
-
-        self.devices: List[BACnetDevice] = []
-        self.objects: Dict[Tuple[str, int], List[dict]] = {}
-
-        # for each discovered Device, create a BAC0.device object
-        # This will read the BACnet objects off of the Device.
-        # Save the BACnet objects in the objects dictionary
+        self.objects: Dict[Tuple[str, int], List[Dict[str, Any]]] = {}
+        self._run_async(
+            self._collect_objects(
+                ip=ip,
+                discover_kwargs=discover_kwargs or {},
+                ping=ping,
+                device_kwargs=device_kwargs or {},
+            )
+        )
+
+    def _run_async(self, coro):
+        loop = asyncio.new_event_loop()
         try:
-            if self.network.discoveredDevices is None:
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(coro)
+            loop.run_until_complete(loop.shutdown_asyncgens())
+        finally:
+            asyncio.set_event_loop(None)
+            loop.close()
+
+    async def _collect_objects(
+        self,
+        *,
+        ip: Optional[str],
+        discover_kwargs: Dict[str, Any],
+        ping: bool,
+        device_kwargs: Dict[str, Any],
+    ):
+        device_kwargs.setdefault("poll", 0)
+
+        async with BAC0.start(ip=ip, ping=ping) as bacnet:
+            await bacnet._discover(**discover_kwargs)
+
+            discovered = getattr(bacnet, "discoveredDevices", None)
+            if not discovered:
                 warnings.warn("BACnet ingress could not find any BACnet devices")
-            for (address, device_id) in self.network.discoveredDevices:  # type: ignore
-                # set poll to 0 to avoid reading the points regularly
-                dev = BAC0.device(address, device_id, self.network, poll=0)
-                self.devices.append(dev)
-                self.objects[(address, device_id)] = []
+                return
+
+            for (address, device_id) in discovered:
+                device = await BAC0.device(address, device_id, bacnet, **device_kwargs)
+                objects: List[Dict[str, Any]] = []
 
-                for bobj in dev.points:
+                for bobj in device.points:
                     obj = bobj.properties.asdict
                     self._clean_object(obj)
-                    self.objects[(address, device_id)].append(obj)
-        finally:
-            for dev in self.devices:
-                self.network.unregister_device(dev)
-            self.network.disconnect()
+                    objects.append(obj)
+
+                self.objects[(address, device_id)] = objects
 
     def _clean_object(self, obj: Dict[str, Any]):
         if "name" in obj:

docs/guides/Dockerfile.bacnet

@@ -4,7 +4,7 @@ WORKDIR /opt
 
 RUN apt update     && apt install -y     python3     python3-pip     && rm -rf /var/lib/apt/lists/*
 
-RUN pip3 install BACpypes
+RUN pip3 install BACpypes --break-system-packages
 
 COPY virtual_bacnet.py virtual_bacnet.py
 COPY BACpypes.ini .

docs/guides/csv-import.md

@@ -67,7 +67,7 @@ tstat2,room345,co2-345,temp-345,sp-345
 tstat3,room567,cow-567,temp-567,sp-567
 ```
 
-We can create a CSV ingress handler using the built-in class ([`CSVIngressHandler`](/reference/apidoc/_autosummary/buildingmotif.ingresses.csv.html#buildingmotif.ingresses.csv.CSVIngress)):
+We can create a CSV ingress handler using the built-in class ([`CSVIngressHandler`](/reference/apidoc/_autosummary/buildingmotif.ingresses.csvingress.html#buildingmotif.ingresses.csvingress.CSVIngress)):
 
 ```python
 from rdflib import Namespace, Graph

docs/guides/docker-compose-bacnet.yml

@@ -1,4 +1,3 @@
-version: "3.4"
 services:
   device:
     build:
@@ -13,4 +12,4 @@ networks:
       driver: default
       config:
         - subnet: "172.24.0.0/16"
-          gateway: "172.24.0.1"
+          gateway: "172.24.0.1"

docs/guides/ingress-bacnet-to-brick.md

@@ -119,7 +119,7 @@ RUN apt update \
     python3-pip \
     && rm -rf /var/lib/apt/lists/*
 
-RUN pip3 install BACpypes
+RUN pip3 install BACpypes --break-system-packages
 
 COPY virtual_bacnet.py virtual_bacnet.py
 COPY BACpypes.ini .''')
@@ -188,12 +188,19 @@ We use the `buildingmotif.ingresses.bacnet.BACnetNetwork` ingress module to pull
 ```{code-cell} python3
 from buildingmotif.ingresses.bacnet import BACnetNetwork
 
-bacnet = BACnetNetwork("172.24.0.1/32") # don't change this if you are using the docker compose setup
+bacnet = BACnetNetwork(
+    "172.24.0.1/32",
+    discover_kwargs={"global_broadcast": True},  # optional, helps find virtual devices
+)
 for rec in bacnet.records:
     print(rec)
 ```
 
-Each of these records has an `rtype` field, which is used by the ingress implementation to differentiate between different kinds of records; here it differentiates between BACnet Devices and BACnet Objects, which have different expressions in Brick. The `fields` attribute cotnains arbitrary key-value pairs, again defined by the ingress implementation, which can be interpreted by another ingress module.
+```{note}
+The `BACnetNetwork` ingress uses BAC0's asynchronous connection helpers under the hood. It opens the network with `BAC0.start` and blocks on discovery by awaiting `bacnet._discover(**discover_kwargs)`, so forwarding options such as `global_broadcast` or `whois` will influence how aggressively the underlying BACnet scan runs. No additional event-loop management is needed when calling the ingress from synchronous code.
+```
+
+Each of these records has an `rtype` field, which is used by the ingress implementation to differentiate between different kinds of records; here it differentiates between BACnet Devices and BACnet Objects, which have different expressions in Brick. The `fields` attribute contains arbitrary key-value pairs, again defined by the ingress implementation, which can be interpreted by another ingress module.
 
 ## BACnet to Brick: an Initial Model