def __init__(self, address, vlan): if _debug: ApplicationLayerStateMachine._debug("__init__ %r %r", address, vlan) ClientStateMachine.__init__(self) # build a name, save the address self.name = "app @ %s" % (address, ) self.address = Address(address) # a network service access point will be needed self.nsap = NetworkServiceAccessPoint() if _debug: ApplicationLayerStateMachine._debug(" - nsap: %r", self.nsap) # bind this as a client of the network service access point bind(self, self.nsap) # create a node, added to the network self.node = Node(self.address, vlan) if _debug: ApplicationLayerStateMachine._debug(" - node: %r", self.node) # bind the stack to the local network self.nsap.bind(self.node)
def __init__(self, local_address, local_network, vlan_address, vlan_network): if _debug: VLANRouter._debug("__init__ %r %r %r %r", local_address, local_network, vlan_address, vlan_network) # 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) # create a generic BIP stack, bound to the Annex J server # on the UDP multiplexer self.bip = BIPSimple() self.annexj = AnnexJCodec() self.mux = UDPMultiplexer(local_address) # bind the bottom layers bind(self.bip, self.annexj, self.mux.annexJ) # bind the BIP stack to the local network self.nsap.bind(self.bip, local_network, local_address) # create a vlan node self.vlan_node = Node(vlan_address) # bind the stack to the vlan network self.nsap.bind(self.vlan_node, vlan_network)
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, vlan_device, vlan_address, aseID=None): if _debug: VLANApplication._debug("__init__ %r %r aseID=%r", vlan_device, vlan_address, aseID) ApplicationIOController.__init__(self, vlan_device, vlan_address, aseID=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, address=vlan_address) # keep track of requests to line up responses self._request = None if _debug: VLANApplication._debug(" - nsap.local_address: %r", self.nsap.local_address)
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, address, vlan): if _debug: ApplicationLayerStateMachine._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: ApplicationLayerStateMachine._debug(" - address: %r", self.address) # continue with initialization ApplicationServiceElement.__init__(self) ClientStateMachine.__init__(self, name=local_device.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(local_device) # the segmentation state machines need access to some device # information cache, usually shared with the application self.smap.deviceInfoCache = 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: ApplicationLayerStateMachine._debug(" - node: %r", self.node) # bind the stack to the local network self.nsap.bind(self.node)
def bind(self, vlan, address, net): if _debug: VLANRouter._debug("bind %r %r %r", vlan, address, net) # create a VLAN node for the router with the given address vlan_node = Node(Address(address)) # add it to the VLAN vlan.add_node(vlan_node) # bind the router stack to the vlan network through this node self.nsap.bind(vlan_node, net) if _debug: _log.debug(" - bound to vlan")
def add_network(self, address, vlan, net): if _debug: RouterNode._debug("add_network %r %r %r", address, vlan, net) # convert the address to an Address address = Address(address) # create a node, added to the network node = Node(address, vlan) if _debug: RouterNode._debug(" - node: %r", node) # bind the BIP stack to the local network self.nsap.bind(node, net)
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: SnifferStateMachine._debug("__init__ %r %r", address, vlan) ClientStateMachine.__init__(self) # save the name and address self.name = address self.address = Address(address) # create a promiscuous node, added to the network self.node = Node(self.address, vlan, promiscuous=True) if _debug: SnifferStateMachine._debug(" - node: %r", self.node) # bind this to the node bind(self, self.node)
def __init__(self, node_count): if _debug: TNetwork._debug("__init__ %r", node_count) StateMachineGroup.__init__(self) self.vlan = Network(broadcast_address=0) for i in range(node_count): node = Node(i + 1, self.vlan) # bind a client state machine to the node csm = ClientStateMachine() bind(csm, node) # add it to this group self.append(csm)
def __init__(self, vlan): if _debug: SnifferNode._debug("__init__ %r", vlan) # save the name and give it a blank address self.name = "sniffer" self.address = Address() # continue with initialization Client.__init__(self) # create a promiscuous node, added to the network self.node = Node(self.address, vlan, promiscuous=True) if _debug: SnifferNode._debug(" - node: %r", self.node) # bind this to the node bind(self, self.node)
def __init__(self, address, vlan): if _debug: NetworkLayerNode._debug("__init__ %r %r", address, vlan) ClientStateMachine.__init__(self) # save the name and address self.name = address self.address = Address(address) # create a network layer encoder/decoder self.codec = NPDUCodec() if _debug: SnifferNode._debug(" - codec: %r", self.codec) # create a node, added to the network self.node = Node(self.address, vlan) if _debug: SnifferNode._debug(" - node: %r", self.node) # bind this to the node bind(self, self.codec, self.node)
def __init__(self, local_address: str): Network.__init__(self, broadcast_address=LocalBroadcast()) # create the VLAN router, bind it to the local network address = Address(local_address) self._router = _VLANRouter(address, 0) self._address_index = 1 # create a node for the router, address 1 on the VLAN router_node = Node(Address(self._address_index.to_bytes(4, "big"))) self._address_index += 1 self.add_node(router_node) # bind the router stack to the vlan network through this node self._router.bind(router_node, 1) self._router.start() self._sensors: Dict[int, Sensor] = {}
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, 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: VLANConsoleApplication._debug("__init__ %r %r aseID=%r", vlan_device, vlan_address, aseID) global args # normal initialization ApplicationIOController.__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 main(): global args, this_application # parse the command line arguments parser = ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter, ) # add an argument for interval parser.add_argument( "addr1", type=str, help="address of first network", ) # add an argument for interval parser.add_argument( "net1", type=int, help="network number of first network", ) # add an argument for interval parser.add_argument( "net2", type=int, help="network number of second network", ) # add an argument for how many virtual devices parser.add_argument( "--count", type=int, help="number of virtual devices", default=1, ) # add an argument for how many virtual devices parser.add_argument( "--rpm", help="enable read property multiple", action="store_true", ) # add an argument for including the property list parser.add_argument( "--plist", help="enable property list property", action="store_true", ) # now parse the arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) local_address = Address(args.addr1) local_network = args.net1 vlan_network = args.net2 # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network) # create a VLAN vlan = Network(broadcast_address=LocalBroadcast()) # create a node for the router, address 1 on the VLAN router_addr = Address(1) router_node = Node(router_addr) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network, router_addr) # send network topology deferred(router.nse.i_am_router_to_network) # add the dynamic property list if args.plist: RandomAnalogValueObject.properties.append(CurrentPropertyList()) # register it now that all its properties are defined register_object_type(RandomAnalogValueObject, vendor_id=999) # console is the first device device_number = 2 device_instance = vlan_network * 100 + device_number _log.debug(" - console device_instance: %r", device_instance) # make a vlan device object vlan_device = LocalDeviceObject( objectName="VLAN Console Node %d" % (device_instance, ), objectIdentifier=("device", device_instance), maxApduLengthAccepted=1024, segmentationSupported="noSegmentation", vendorIdentifier=15, ) _log.debug(" - vlan_device: %r", vlan_device) vlan_address = Address(device_number) _log.debug(" - vlan_address: %r", vlan_address) # make the console application, add it to the network this_application = VLANConsoleApplication(vlan_device, vlan_address) vlan.add_node(this_application.vlan_node) _log.debug(" - this_application: %r", this_application) # make a console this_console = VLANConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # make a random value object ravo = RandomAnalogValueObject( objectIdentifier=("analogValue", 1), objectName="Random-1-%d" % (device_instance, ), ) _log.debug(" - ravo: %r", ravo) # add it to the device this_application.add_object(ravo) # make some more devices for device_number in range(3, 3 + args.count - 1): # device identifier is assigned from the address device_instance = vlan_network * 100 + device_number _log.debug(" - device_instance: %r", device_instance) # make a vlan device object vlan_device = LocalDeviceObject( objectName="VLAN Node %d" % (device_instance, ), objectIdentifier=("device", device_instance), maxApduLengthAccepted=1024, segmentationSupported="noSegmentation", vendorIdentifier=15, ) _log.debug(" - vlan_device: %r", vlan_device) vlan_address = Address(device_number) _log.debug(" - vlan_address: %r", vlan_address) # make the application, add it to the network vlan_app = VLANApplication(vlan_device, vlan_address) vlan.add_node(vlan_app.vlan_node) _log.debug(" - vlan_app: %r", vlan_app) # make a random value object ravo = RandomAnalogValueObject( objectIdentifier=("analogValue", 1), objectName="Random-1-%d" % (device_instance, ), ) _log.debug(" - ravo: %r", ravo) # add it to the device vlan_app.add_object(ravo) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) local_address = Address(args.addr1) local_network = args.net1 vlan_address = Address(args.addr2) vlan_network = args.net2 # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network) # create a VLAN vlan = Network() # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network) # device identifier is assigned from the address device_instance = vlan_network * 100 + int(args.addr2) _log.debug(" - device_instance: %r", device_instance) # make a vlan device object vlan_device = \ LocalDeviceObject( objectName="VLAN Node %d" % (device_instance,), objectIdentifier=('device', device_instance), maxApduLengthAccepted=1024,
def main(): # parse the command line arguments # parser = ArgumentParser( # description=__doc__, # formatter_class=argparse.RawDescriptionHelpFormatter, # ) # # # add an argument for interval # parser.add_argument('addr1', type=str, # help='address of first network', # ) # # # add an argument for interval # parser.add_argument('net1', type=int, # help='network number of first network', # ) # # # add an argument for interval # parser.add_argument('addr2', type=str, # help='address of second network', # ) # # # add an argument for interval # parser.add_argument('net2', type=int, # help='network number of second network', # ) # # # now parse the arguments # args = parser.parse_args() # # if _debug: _log.debug("initialization") # if _debug: _log.debug(" - args: %r", args) # local_address = Address(args.addr1) # local_network = args.net1 # vlan_address = Address(args.addr2) # vlan_network = args.net2 local_address = Address('130.91.139.93') local_network = 0 vlan_address = Address(5) vlan_network = 9997 # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network) # create a VLAN vlan = Network() # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network) # device identifier is assigned from the address # device_instance = vlan_network * 100 + int(args.addr2) device_instance = vlan_network * 100 + 5 # vlan_address device_instance2 = vlan_network * 100 + 6 _log.debug(" - device_instance: %r", device_instance) # make a vlan device object # vlan_device = \ # LocalDeviceObject( # objectName="VLAN Node %d" % (device_instance,), # objectIdentifier=('device', device_instance), # maxApduLengthAccepted=1024, # segmentationSupported='noSegmentation', # vendorIdentifier=15, # ) #ADDED vlan_device = \ LocalDeviceObject( objectName='laptopBehindNetwork', objectIdentifier=device_instance, maxApduLengthAccepted=1024, segmentationSupported='noSegmentation', vendorIdentifier=15, ) vlan_device2 = \ LocalDeviceObject( objectName='laptopBehindNetwork2', objectIdentifier=device_instance2, maxApduLengthAccepted=1024, segmentationSupported='noSegmentation', vendorIdentifier=15, ) #ADDED _log.debug(" - vlan_device: %r", vlan_device) # make the application, add it to the network vlan_app = VLANApplication(vlan_device, vlan_address) vlan.add_node(vlan_app.vlan_node) vlan_app2 = VLANApplication(vlan_device2, Address(6)) vlan.add_node(vlan_app2.vlan_node) _log.debug(" - vlan_app: %r", vlan_app) #ADDED services_supported = vlan_app.get_services_supported() # let the device object know vlan_device.protocolServicesSupported = services_supported.value services_supported = vlan_app2.get_services_supported() # let the device object know vlan_device2.protocolServicesSupported = services_supported.value #ADDED # make a random value object # ravo = RandomAnalogValueObject( # objectIdentifier=('analogValue', 1), # objectName='Device%d/Random1' % (device_instance,), # ) ravo = ModbusAnalogInputObject( objectIdentifier=('analogInput', 1), objectName='Device%d/Modbus1' % (device_instance, ), ) _log.debug(" - ravo1: %r", ravo) # add it to the device vlan_app.add_object(ravo) # make a random value object ravo = RandomAnalogValueObject( objectIdentifier=('analogValue', 1), objectName='Device%d/Random1' % (device_instance2, ), ) # add it to the device vlan_app2.add_object(ravo) _log.debug("running") print('run') run() _log.debug("fini")
def main(): global args, this_device, this_application # parse the command line arguments parser = ConfigArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter, ) # add an argument for interval parser.add_argument('net1', type=int, help='network number of IPv4 network', ) # add an argument for interval parser.add_argument('net2', type=int, help='network number of VLAN network', ) # add an argument for interval parser.add_argument('addr2', type=str, help='address on the VLAN network', ) # now parse the arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) local_network = args.net1 local_address = Address(args.ini.address) if _debug: _log.debug(" - local_network, local_address: %r, %r", local_network, local_address) vlan_network = args.net2 vlan_address = Address(args.addr2) if _debug: _log.debug(" - vlan_network, vlan_address: %r, %r", vlan_network, vlan_address) # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network) # create a VLAN vlan = Network(broadcast_address=LocalBroadcast()) # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network) # send network topology deferred(router.nse.i_am_router_to_network) # make a vlan device object this_device = \ LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=("device", int(args.ini.objectidentifier)), maxApduLengthAccepted=1024, segmentationSupported='noSegmentation', vendorIdentifier=15, ) _log.debug(" - this_device: %r", this_device) # make the application, add it to the network this_application = VLANApplication(this_device, vlan_address) vlan.add_node(this_application.vlan_node) _log.debug(" - this_application: %r", this_application) # make a console this_console = WhoIsIAmConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) _log.debug("running") run() _log.debug("fini")
def main(): # parse the command line arguments parser = ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter, ) # add an argument for interval parser.add_argument( 'addr1', type=str, help='address of first network', ) # add an argument for interval parser.add_argument( 'net1', type=int, help='network number of first network', ) # add an argument for interval parser.add_argument( 'addr2', type=str, help='address of second network', ) # add an argument for interval parser.add_argument( 'net2', type=int, help='network number of second network', ) # now parse the arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) local_address = Address(args.addr1) local_network = args.net1 vlan_address = Address(args.addr2) vlan_network = args.net2 # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network) # create a VLAN vlan = Network(broadcast_address=LocalBroadcast()) # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network) # send network topology deferred(router.nse.i_am_router_to_network) # device identifier is assigned from the address device_instance = vlan_network * 100 + int(args.addr2) _log.debug(" - device_instance: %r", device_instance) # make a vlan device object vlan_device = \ LocalDeviceObject( objectName="VLAN Node %d" % (device_instance,), objectIdentifier=('device', device_instance), maxApduLengthAccepted=1024, segmentationSupported='noSegmentation', vendorIdentifier=15, ) _log.debug(" - vlan_device: %r", vlan_device) # make the application, add it to the network vlan_app = VLANApplication(vlan_device, vlan_address) vlan.add_node(vlan_app.vlan_node) _log.debug(" - vlan_app: %r", vlan_app) # make a random value object ravo = RandomAnalogValueObject( objectIdentifier=('analogValue', 1), objectName='Device%d/Random1' % (device_instance, ), ) _log.debug(" - ravo1: %r", ravo) # add it to the device vlan_app.add_object(ravo) _log.debug("running") run() _log.debug("fini")
def main(): global args # parse the command line arguments parser = ArgumentParser(description=__doc__) # arguments for first network parser.add_argument( 'lan', type=str, help='MQTT network name', ) parser.add_argument( 'addr1', type=str, help='address on MQTT network', ) parser.add_argument( 'net1', type=int, help='network number of MQTT network', ) # VLAN arguments parser.add_argument( 'net2', type=int, help='network number of VLAN', ) parser.add_argument( '--count', type=int, help='number of virtual devices', default=1, ) # additional options for the MQTT client parser.add_argument( '--host', type=str, default=bacpypes_mqtt.default_broker_host, help='broker host address', ) parser.add_argument( '--port', type=int, default=bacpypes_mqtt.default_broker_port, help='broker port', ) parser.add_argument( '--keepalive', type=int, default=bacpypes_mqtt.default_broker_keepalive, help= "maximum period in seconds allowed between communications with the broker", ) # now parse the arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # create the VLAN router, bind it to the local network router = VLANRouter(args.lan, Address(args.addr1), args.net1) # create a VLAN vlan = Network(broadcast_address=LocalBroadcast()) # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, args.net2) # make some devices for device_number in range(2, 2 + args.count): # device identifier is assigned from the address device_instance = args.net2 * 100 + device_number _log.debug(" - device_instance: %r", device_instance) # make a vlan device object vlan_device = \ LocalDeviceObject( objectName="VLAN Node %d" % (device_instance,), objectIdentifier=('device', device_instance), maxApduLengthAccepted=1024, segmentationSupported='noSegmentation', vendorIdentifier=15, ) _log.debug(" - vlan_device: %r", vlan_device) vlan_address = Address(device_number) _log.debug(" - vlan_address: %r", vlan_address) # make the application, add it to the network vlan_app = VLANApplication(vlan_device, vlan_address) vlan.add_node(vlan_app.vlan_node) _log.debug(" - vlan_app: %r", vlan_app) # make a random value object ravo = RandomAnalogValueObject( objectIdentifier=('analogValue', 1), objectName='Random-1-%d' % (device_instance, ), ) _log.debug(" - ravo: %r", ravo) # add it to the device vlan_app.add_object(ravo) # start up the client router.mse.startup() _log.debug("running") run() # shutdown the client router.mse.shutdown() _log.debug("fini")
def main(): # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() # local_address = Address('130.91.139.93/22') # local_network = 0 # vlan_network = 9997 local_address = Address(args.ini.localip) local_network = int(args.ini.localnetwork) vlan_network = int(args.ini.vlannetwork) foreign_address = Address(args.ini.bbmdip) mb_timeout = verify_ini_vars(args.ini, 'modbustimeout', 1000) mbtcp_timeout = verify_ini_vars(args.ini, 'mbtcpservertimeout', 5000) max_apdu_len = verify_ini_vars(args.ini, 'maxapdulength', 1024) segmentation_support = verify_ini_vars(args.ini, 'segmentationsupport', 'noSegmentation') vendor_id = verify_ini_vars(args.ini, 'vendorid', 15) bcnt_obj_update_interval = verify_ini_vars(args.ini, 'bacnetobjectupdateinterval', 1000) default_cov_inc = verify_ini_vars(args.ini, 'defaultcovincrement', 0.0) reboot_check_time = verify_ini_vars(args.ini, 'rebootchecktime', 1800000) # modbus_only = verify_ini_vars(args.ini, 'modbusonly', 0) modbus_translation = verify_ini_vars(args.ini, 'modbustranslation', 1) modbus_translation = True if modbus_translation == 1 else False # modbus_word_order = verify_ini_vars(args.ini, 'modbuswordorder', 0) # modbus_word_order = 'lsw' if modbus_word_order == 0 else 'msw' # if not modbus_only: reboot_queue = queue.Queue() reboot_queue.put_nowait(_time()) # create the VLAN router, bind it to the local network router = VLANRouter(local_address, local_network, foreign_address, rebootQueue=reboot_queue) # create a VLAN vlan = Network() # create a node for the router, address 1 on the VLAN router_node = Node(Address(1)) vlan.add_node(router_node) # bind the router stack to the vlan network through this node router.nsap.bind(router_node, vlan_network) mb_to_bank_queue = queue.Queue() bank_to_bcnt_queue = queue.Queue() object_val_dict = {} mb_req_dict = {} unq_ip_last_resp_dict = {} dev_dict = {} app_dict = {} for fn in os.listdir(sys.path[0] + '/DeviceList'): if fn.endswith('.json'): # and fn.startswith('DRL'): print(sys.path[0] + '/DeviceList/' + fn) json_raw_str = open(sys.path[0] + '/DeviceList/' + fn, 'r') map_dict = json.load(json_raw_str) good_inst = modbusregisters.add_meter_instance_to_dicts(map_dict, mb_to_bank_queue, object_val_dict, mb_req_dict, unq_ip_last_resp_dict) json_raw_str.close() if good_inst: try: dev_inst = map_dict['deviceInstance'] dev_ip = map_dict['deviceIP'] dev_mb_id = map_dict['modbusId'] except KeyError: _log.debug("json key error for %s", fn) continue dev_name = map_dict.get('deviceName', 'default device name') dev_desc = map_dict.get('deviceDescription', 'UTILITY; Feeds: BUILDING_EQUATION; From: ' 'ELECTRIC_LINES; Serno: SERIAL_NUMBER; IP: METER_IP; ' 'MBid: MODBUS_ID') dev_map_name = map_dict.get('mapName', 'default map') dev_map_rev = map_dict.get('mapRev', 'default map rev') dev_meter_model = map_dict.get('meterModelName', 'default meter model') dev_mb_port = map_dict.get('modbusPort', 502) dev_cov = map_dict.get('covSubscribe', 'no') dev_mb_resp_word_order = map_dict.get('meterRespWordOrder', 'lsw') dev_dict[dev_inst] = modbusbacnetclasses.ModbusLocalDevice( objectName=dev_name, objectIdentifier=('device', dev_inst), description=dev_desc, maxApduLengthAccepted=max_apdu_len, segmentationSupported=segmentation_support, vendorIdentifier=vendor_id, deviceIp=dev_ip, modbusId=dev_mb_id, modbusMapName=dev_map_name, modbusMapRev=dev_map_rev, deviceModelName=dev_meter_model, modbusPort=dev_mb_port, meterRespWordOrder=dev_mb_resp_word_order, ) if dev_cov == 'yes': app_dict[dev_inst] = ModbusCOVVLANApplication(dev_dict[dev_inst], ip_to_bcnt_address(dev_ip, dev_mb_id)) else: app_dict[dev_inst] = ModbusVLANApplication(dev_dict[dev_inst], ip_to_bcnt_address(dev_ip, dev_mb_id)) vlan.add_node(app_dict[dev_inst].vlan_node) services_supported = app_dict[dev_inst].get_services_supported() dev_dict[dev_inst].protocolServicesSupported = services_supported.value val_types = {'holdingRegisters': 3, 'inputRegisters': 4, 'coilBits': 1, 'inputBits': 2} # create objects for device for val_type, mb_func in val_types.items(): if val_type not in map_dict or val_type not in ['holdingRegisters', 'inputRegisters']: continue mb_dev_wo = map_dict[val_type].get('wordOrder', 'lsw') mb_dev_poll_time = map_dict[val_type].get('pollingTime', 30000) for register in map_dict[val_type]['registers']: try: if register['poll'] == 'no': continue obj_inst = register['objectInstance'] obj_reg_start = register['start'] obj_reg_format = register['format'] except KeyError: continue obj_name = register.get('objectName', 'default object name') obj_description = register.get('objectDescription', 'default object description') obj_cov_inc = register.get('covIncrement', default_cov_inc) if obj_reg_format in modbusregisters.one_register_formats: obj_num_regs = 1 elif obj_reg_format in modbusregisters.two_register_formats: obj_num_regs = 2 elif obj_reg_format in modbusregisters.three_register_formats: obj_num_regs = 3 elif obj_reg_format in modbusregisters.four_register_formats: obj_num_regs = 4 else: continue obj_units_id = register.get('unitsId', 95) # 95 is noUnits obj_pt_scale = register.get('pointScale', [0, 1, 0, 1]) obj_eq_m = (obj_pt_scale[3] - obj_pt_scale[2]) / (obj_pt_scale[1] - obj_pt_scale[0]) obj_eq_b = obj_pt_scale[2] - obj_eq_m * obj_pt_scale[0] maio = modbusbacnetclasses.ModbusAnalogInputObject( objectIdentifier=('analogInput', obj_inst), objectName=obj_name, description=obj_description, modbusFunction=mb_func, registerStart=obj_reg_start, numberOfRegisters=obj_num_regs, registerFormat=obj_reg_format, wordOrder=mb_dev_wo, # modbusScaling=[obj_eq_m, obj_eq_b], modbusScaling=ArrayOf(Real)([obj_eq_m, obj_eq_b]), units=obj_units_id, covIncrement=obj_cov_inc, updateInterval=int(mb_dev_poll_time / 10.0), resolution=0.0, reliability='communicationFailure', statusFlags=[0, 1, 0, 0], modbusCommErr='noTcpConnection', eventState='normal', outOfService=False, ) # _log.debug(" - maio: %r", maio) app_dict[dev_inst].add_object(maio) print('init modbus bank') obj_val_bank = modbusregisters.ModbusFormatAndStorage(mb_to_bank_queue, bank_to_bcnt_queue, object_val_dict) print('init modbus req launcher') mb_req_launcher = modbusregisters.ModbusRequestLauncher(mb_req_dict, unq_ip_last_resp_dict) print('init check for reboot') reboot_task = RebootWithNoTraffic(reboot_queue, time_to_check=reboot_check_time) print('init update bacnet objects task') update_objects = modbusbacnetclasses.UpdateObjectsFromModbus(bank_to_bcnt_queue, app_dict, bcnt_obj_update_interval) print('start bank and launcher') obj_val_bank.start() mb_req_launcher.start() # end if not modbus only if B_RPI_GPIO_EXISTS: print('init led heartbeat task') led_heartbeat = LEDHeartbeat(heartbeat_on_time=1000, pin_board_num=11) else: print('no heartbeat here') # set up forked modbus server socketserver.TCPServer.allow_reuse_address = True ModbusRequestHandler = modbusserver.make_modbus_request_handler(app_dict, mb_timeout=mb_timeout, tcp_timeout=mbtcp_timeout, mb_translation=modbus_translation) modbusserver.ThreadedTCPServer.daemon_threads = True modbusserver.ThreadedTCPServer.allow_reuse_address = True modbus_thread_server = modbusserver.ThreadedTCPServer((str(args.ini.localip).split('/')[0], 502), ModbusRequestHandler) mb_server_thread = threading.Thread(target=modbus_thread_server.serve_forever) mb_server_thread.daemon = True print('modbus server start') mb_server_thread.start() _log.debug("running") print('bacnet start') run() modbus_thread_server.socket.close() print('PiGateway finish') _log.debug("fini")