Faster than real time simulation-network

[EttoreZ]

Hey all thank you for all the work! We developed a BACnet interface around our building and HVAC simulation engine using BACpypes and so far it works great for real time simulations. However, we have been thinking on how to make the simulation and the network run in faster than real time and what are the nuances around BACpypes / BACpypes3 in order to achieve that. Thank you for your help!

[bbartling]

If I understand correctly, you want to just remove networking for a simulation purposes ... so would just be requiring raw data then, right? IE., just as temperature sensor values?

I think you could just make something up with Py getters and setters and object orientated programming....

class AnalogValue:
    def __init__(self, name, initial_value=0.0):
        self.name = name
        self.present_value = initial_value

    def read(self):
        return self.present_value

    def write(self, value):
        print(f"[{self.name}] Writing new value: {value}")
        self.present_value = value


class MockBACnetDevice:
    def __init__(self, device_id):
        self.device_id = device_id
        self.objects = {}

    def add_object(self, obj_name, bacnet_obj):
        self.objects[obj_name] = bacnet_obj

    def read_property(self, obj_name):
        return self.objects[obj_name].read()

    def write_property(self, obj_name, value):
        self.objects[obj_name].write(value)


# Simulate network
class BACnetNetworkSimulator:
    def __init__(self):
        self.devices = {}

    def register_device(self, device):
        self.devices[device.device_id] = device

    def read_from_device(self, target_id, obj_name):
        device = self.devices[target_id]
        return device.read_property(obj_name)

    def write_to_device(self, target_id, obj_name, value):
        device = self.devices[target_id]
        device.write_property(obj_name, value)


# Example Usage
device_A = MockBACnetDevice(device_id=1001)
device_B = MockBACnetDevice(device_id=1002)

# Add AV objects
device_A.add_object("zone_temp", AnalogValue("zone_temp", 72.0))
device_B.add_object("zone_temp_cmd", AnalogValue("zone_temp_cmd", 0.0))

# Register to mock network
network = BACnetNetworkSimulator()
network.register_device(device_A)
network.register_device(device_B)

# Simulate write from A to B (like BACnet WriteProperty)
temp = network.read_from_device(1001, "zone_temp")
network.write_to_device(1002, "zone_temp_cmd", temp)

# Output B's value
print(device_B.read_property("zone_temp_cmd"))  # ➜ 72.0

[bbartling]

thats just whipping something up but you maybe able to get more bacpypes3 like ....

[EttoreZ]

Thank you Ben for the quick reply, not quite! I will try to be more clear. We have our simulation engine that allows users to read data and send control commands to the simulated HVAC through rest APIs and the co-simulation (simulation engine + external controller object) can run at whatever speed the computational resources allow it to run. We developed a BACnet interface wrap using BACpypes to expose the data and control points to BACnet (by creating a digital BACnet device and connecting all the simulation points to it) so that controllers and interfaces operating in BACnet could interact with our simulation. Apart from exposing the points to BACnet network to the interface advances the simulation in real time and updates the data at a certain frequency. Now I could advance the simulation faster (2X, 5X, 10X, etc...), but the BACnet points timestamp will still be associated with the normal clock time and lag behind. So I am trying to understand if it is possible to accelerate the whole network to follow the simulation time at 2X, 5X, 10X, etc.. the normal flow of time, or if anyone facing a similar problem found a different solution.

[bbartling]

Gosh interesting ... Hmmm basically to simulate networking, right? in 2X, 5X, 10X .... I am probably the wrong person to ask this question but its almost like you wouldnt to remove networking from the equation as that is almost more a real time technology thing right?

[EttoreZ]

Thank you @bbartling for your reply. I admit that I am new to BACnet and even more so on bacpypes. Maybe I am asking the wrong question. I guess from what @acedrew is suggesting it should the BACnet application communicating with our interface that should be aware of the accelerated time rather than the other way around (i.e. we tested with BASView3 and plotted the trended data, I assume they calculated the timestamp based on their own internal clock).

[acedrew]

@EttoreZ is the timestamp being applied by bacpypes3, or the application reading the data?

[acedrew]

Or are you referring to a trendLog object and its entries?

[EttoreZ]

Hey @acedrew , thank you for the responses! I admit that I am new to BACnet and even more so on bacpypes.
For the first question This is the BACnet interface that was developed BOPTEST-BACnet-proxy. I assume that whatever BACnet application reads the points may assign the timestamp?
For the second question, I never used the trandLog object, but if it's trended data (time,value) provided by bacpypes to the BACnet application I would like for it to show the timesteps according to the simulation time and not in real time.

[JoelBender]

There is a clocked_test.py module in the tests that wraps the asyncio event loop and allows the test to specify an amount of time to "accelerate" or skip forward. For example, if you have a virtual BACnet device that is supposed to wake up every n seconds and send out a Read Property Request, you can write that as a specialized subclass of Application and use a while True: await asyncio.sleep(1); await app.read_property(...) loop.

Let's say you have a CVS file that contains a list of timestamp, value, value, ... rows that you want to feed into a device and see its response. The outer simulation loop reads the row, waits for the timestamp (maybe a delta time), changes some values in an application which in turn triggers some kind of activity. There are lots of options!

The clocked tests in BACpypes3 use this feature, along with state machines to determine the path through combinations of requests and responses.

[EttoreZ]

Thank you @JoelBender for your answer I will look into clocked_test.py and experiment from there.