def __init__(self, localDevice, localAddress, aseID=None):
if _debug:
TestApplication._debug("__init__ %r %r aseID=%r", localDevice,
localAddress, aseID)
Application.__init__(self, localDevice, localAddress, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(localDevice)
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a multiplexer and device-to-device service
self.mux = TCPServerMultiplexer(self.localAddress)
# add this to the list of adapters
self.d2d = DeviceToDeviceServerService(self.mux, self.nsap, None)
def __init__(self, vlan_device, vlan_address, aseID=None):
if _debug:
VLANApplication._debug("__init__ %r %r aseID=%r", vlan_device,
vlan_address, aseID)
Application.__init__(self, vlan_device, local_address, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(vlan_device)
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a vlan node at the assigned address
self.vlan_node = Node(vlan_address)
# bind the stack to the node, no network number
self.nsap.bind(self.vlan_node)
def __init__(self, vlan_device, vlan_address, aseID=None):
if _debug: VLANApplication._debug("__init__ %r %r aseID=%r", vlan_device, vlan_address, aseID)
Application.__init__(self, vlan_device, vlan_address, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(vlan_device)
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a vlan node at the assigned address
self.vlan_node = Node(vlan_address)
# bind the stack to the node, no network number
self.nsap.bind(self.vlan_node)
def __init__(self, vlan_device: LocalDeviceObject, vlan_address: Address) -> None:
if _debug:
_VLANApplication._debug("__init__ %r %r", vlan_device, vlan_address)
Application.__init__(self, localDevice=vlan_device, aseID=None)
# include a application decoder
self._asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self._smap = StateMachineAccessPoint(vlan_device)
# the segmentation state machines need access to the same device
# information cache as the application
self._smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self._nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self._nse = NetworkServiceElement()
bind(self._nse, self._nsap)
# bind the top layers
bind(self, self._asap, self._smap, self._nsap)
# create a vlan node at the assigned address
self._vlan_node = Node(vlan_address)
# bind the stack to the node, no network number
self._nsap.bind(self._vlan_node)
def __init__(self, *args, **kwargs):
"""
This function constructs the application object.
:return: BasicApplication instance
"""
# call constructor of predecessor class
BACpypesApplication.__init__(self, *args, **kwargs)
# reset protected properties
self.protected_properties = (
# device itself
self.objectName.keys()[0],
# python program
'configuration',
# program control
'control',
)
# initialize device dictionary
self.known_devices = {}
# initialize remote subscriptions
self.remote_subscriptions = {}
# set event
self.update_devices_now = Event()
def __init__(self, address, vlan):
if _debug: BIPBBMDApplication._debug("__init__ %r %r", address, vlan)
# build a name, save the address
self.name = "app @ %s" % (address,)
self.address = Address(address)
if _debug: BIPBBMDApplication._debug(" - address: %r", self.address)
# build a local device object
local_device = TestDeviceObject(
objectName=self.name,
objectIdentifier=('device', 999),
vendorIdentifier=999,
)
# continue with initialization
Application.__init__(self, local_device, self.address)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(local_device)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# BACnet/IP interpreter
self.bip = BIPBBMD(self.address)
self.annexj = AnnexJCodec()
# build an address, full mask
bdt_address = "%s/32:%d" % self.address.addrTuple
if _debug: BIPBBMDNode._debug(" - bdt_address: %r", bdt_address)
# add itself as the first entry in the BDT
self.bip.add_peer(Address(bdt_address))
# fake multiplexer has a VLAN node in it
self.mux = FauxMultiplexer(self.address, vlan)
# bind the stack together
bind(self.bip, self.annexj, self.mux)
# bind the stack to the local network
self.nsap.bind(self.bip)
def __init__(self, objectName, deviceInstance, address, aseID=None):
if _debug:
VLANApplication._debug("__init__ %r %r %r aseID=%r", objectName,
deviceInstance, address, aseID)
# make an address
vlan_address = Address(address)
_log.debug(" - vlan_address: %r", vlan_address)
# make a device object
vlan_device = LocalDeviceObject(
objectName=objectName,
objectIdentifier=("device", deviceInstance),
maxApduLengthAccepted=1024,
segmentationSupported="noSegmentation",
vendorIdentifier=15,
)
_log.debug(" - vlan_device: %r", vlan_device)
# continue with the initialization
Application.__init__(self, vlan_device, vlan_address, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(vlan_device)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a vlan node at the assigned address
self.vlan_node = Node(vlan_address)
if _debug:
VLANApplication._debug(" - vlan_node: %r", self.vlan_node)
# bind the stack to the node, no network number
self.nsap.bind(self.vlan_node)
if _debug:
VLANApplication._debug(" - node bound")
def __init__(self, address, vlan):
if _debug: ApplicationNode._debug("__init__ %r %r", address, vlan)
# build a name, save the address
self.name = "app @ %s" % (address, )
self.address = Address(address)
# build a local device object
local_device = TestDeviceObject(
objectName=self.name,
objectIdentifier=('device', int(address)),
vendorIdentifier=999,
)
# build an address and save it
self.address = Address(address)
if _debug: ApplicationNode._debug(" - address: %r", self.address)
# continue with initialization
Application.__init__(self, local_device)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(local_device)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a node, added to the network
self.node = Node(self.address, vlan)
if _debug: ApplicationNode._debug(" - node: %r", self.node)
# bind the stack to the local network
self.nsap.bind(self.node)
def __init__(self, localDevice, vlan):
if _debug:
ApplicationStateMachine._debug("__init__ %r %r", localDevice, vlan)
# build an address and save it
self.address = Address(localDevice.objectIdentifier[1])
if _debug:
ApplicationStateMachine._debug(" - address: %r", self.address)
# continue with initialization
Application.__init__(self, localDevice, self.address)
StateMachine.__init__(self, name=localDevice.objectName)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(localDevice)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a node, added to the network
self.node = Node(self.address, vlan)
# bind the network service to the node, no network number
self.nsap.bind(self.node)
# placeholder for the result block
self.confirmed_private_result = None
def __init__(self, localDevice, localAddress, aseID=None):
if _debug:
TestProxyApplication._debug("__init__ %r %r aseID=%r", localDevice,
localAddress, aseID)
Application.__init__(self, localDevice, localAddress, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(localDevice)
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a generic BIP stack, bound to the Annex J server
# on the UDP multiplexer
self.bip = BIPSimple()
self.annexj = AnnexJCodec()
self.mux = UDPMultiplexer(self.localAddress)
# bind the bottom layers
bind(self.bip, self.annexj, self.mux.annexJ)
# bind the BIP stack to network 5, the 'local' network
self.nsap.bind(self.bip, 5, self.localAddress)
# create a multiplexer for the service
self.mux = TCPServerMultiplexer(self.localAddress)
# proxy connections are bound to the nsap
self.proxyServer = TestProxyServer(self.mux, self.nsap)
def __init__(self,
vlan_device,
vlan_address,
aseID=None,
register_reader=None):
if _debug:
VLANApplication._debug("__init__ %r %r aseID=%r", vlan_device,
vlan_address, aseID)
Application.__init__(self, vlan_device, vlan_address, aseID)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(vlan_device)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a vlan node at the assigned address
self.vlan_node = Node(vlan_address)
# bind the stack to the node, no network number
self.nsap.bind(self.vlan_node)
# set register reader class that will look into block of registers for all associated slaves
self.register_reader = register_reader
def __init__(self, vlan_device, vlan_address, aseID=None):
if _debug:
VLANApplication._debug("__init__ %r %r aseID=%r", vlan_device,
vlan_address, aseID)
global args
# normal initialization
Application.__init__(self, vlan_device, aseID=aseID)
# optional read property multiple
if args.rpm:
self.add_capability(ReadWritePropertyMultipleServices)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(vlan_device)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a vlan node at the assigned address
self.vlan_node = Node(vlan_address)
# bind the stack to the node, no network number, no addresss
self.nsap.bind(self.vlan_node)
def __init__(self,
localDevice,
localAddress,
deviceInfoCache=None,
aseID=None):
if _debug:
ReadPointListApplication._debug(
"__init__ %r %r deviceInfoCache=%r aseID=%r", localDevice,
localAddress, deviceInfoCache, aseID)
global args
Application.__init__(self, localDevice, deviceInfoCache, aseID=aseID)
RecurringTask.__init__(self, args.interval * 1000)
# local address might be useful for subclasses
if isinstance(localAddress, Address):
self.localAddress = localAddress
else:
self.localAddress = Address(localAddress)
# include a application decoder
self.asap = ApplicationServiceAccessPoint()
# pass the device object to the state machine access point so it
# can know if it should support segmentation
self.smap = StateMachineAccessPoint(localDevice)
# the segmentation state machines need access to the same device
# information cache as the application
self.smap.deviceInfoCache = self.deviceInfoCache
# a network service access point will be needed
self.nsap = NetworkServiceAccessPoint()
# give the NSAP a generic network layer service element
self.nse = NetworkServiceElement()
bind(self.nse, self.nsap)
# bind the top layers
bind(self, self.asap, self.smap, self.nsap)
# create a generic BIP stack, bound to the Annex J server
# on the UDP multiplexer
self.bip = BIPSimple()
self.annexj = AnnexJCodec()
self.mux = UDPMultiplexer(self.localAddress)
# bind the bottom layers
bind(self.bip, self.annexj, self.mux.annexJ)
# bind the BIP stack to the network, no network number
self.nsap.bind(self.bip)
# install the task
self.install_task()
# timer
self.start_time = None
# pending requests
self.pending_requests = {}
def __init__(self, localDevice, localAddress, aseID=None):
if _debug:
TestApplication._debug("__init__ %r %r aseID=%r", localDevice,
localAddress, aseID)
Application.__init__(self, localDevice, localAddress, aseID)
def __init__(self, localDevice, localAddress, aseID=None):
if _debug: TestApplication._debug("__init__ %r %r aseID=%r", localDevice, localAddress, aseID)
Application.__init__(self, localDevice, localAddress, aseID)
