def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # provide max segments accepted if any kind of segmentation supported if args.ini.segmentationsupported != 'noSegmentation': this_device.maxSegmentsAccepted = int(args.ini.maxsegmentsaccepted) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) if _debug: _log.debug(" - this_application: %r", this_application) # make a console this_console = ReadPropertyAnyConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): global this_application, context # parse the command line arguments parser = ConfigArgumentParser(description=__doc__) parser.add_argument( "address", help="address of server", ) parser.add_argument( "objtype", help="object type", ) parser.add_argument( "objinst", type=int, help="object instance", ) args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # set the context, the collection of the above parameters context = args.address, args.objtype, args.objinst if _debug: _log.debug(" - context: %r", context) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # get the services supported services_supported = this_application.get_services_supported() if _debug: _log.debug(" - services_supported: %r", services_supported) # let the device object know this_device.protocolServicesSupported = services_supported.value # make a console this_console = ReadWritePropertyConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): global this_device, this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) if _debug: _log.debug(" - this_device: %r", this_device) # build a bit string that knows about the bit names pss = ServicesSupported() pss['whoIs'] = 1 pss['iAm'] = 1 pss['readProperty'] = 1 pss['writeProperty'] = 1 # set the property value to be just the bits this_device.protocolServicesSupported = pss.value # make a simple application this_application = WhoIsIAmApplication( this_device, args.ini.address, Address(args.ini.foreignbbmd), int(args.ini.foreignttl), ) if _debug: _log.debug(" - this_application: %r", this_application) # get the services supported services_supported = this_application.get_services_supported() if _debug: _log.debug(" - services_supported: %r", services_supported) # let the device object know this_device.protocolServicesSupported = services_supported.value # make a console this_console = WhoIsIAmConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): global args # parse the command line arguments parser = ConfigArgumentParser(description=__doc__) # add an option to override the sleep time parser.add_argument( '--sleep', type=float, help="sleep before returning the value", default=SLEEP_TIME, ) # parse the command line arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=('device', int(args.ini.objectidentifier)), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a sample application this_application = BIPSimpleApplication(this_device, args.ini.address) # get the services supported services_supported = this_application.get_services_supported() if _debug: _log.debug(" - services_supported: %r", services_supported) # let the device object know this_device.protocolServicesSupported = services_supported.value # make some random input objects for i in range(1, RANDOM_OBJECT_COUNT + 1): ravo = RandomAnalogValueObject( objectIdentifier=('analogValue', i), objectName='Random-%d' % (i, ), ) _log.debug(" - ravo: %r", ravo) this_application.add_object(ravo) # make sure they are all there _log.debug(" - object list: %r", this_device.objectList) _log.debug("running") run() _log.debug("fini")
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # get the services supported services_supported = this_application.get_services_supported() if _debug: _log.debug(" - services_supported: %r", services_supported) # let the device object know this_device.protocolServicesSupported = services_supported.value thread_list = [] # loop through the address and point lists for addr, points in point_list: # create a thread read_thread = ReadPointListThread(addr, points) if _debug: _log.debug(" - read_thread: %r", read_thread) thread_list.append(read_thread) # create a thread supervisor thread_supervisor = ThreadSupervisor(thread_list) # start it running when the core is running deferred(thread_supervisor.start) _log.debug("running") run() # dump out the results for read_thread in thread_list: for request, response in zip(read_thread.point_list, read_thread.response_values): print(request, response) _log.debug("fini")
def main(): # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), _dcc_password="******", ) # make a sample application this_application = ReadPropertyMultipleApplication(this_device, args.ini.address) # make a random input object ravo1 = RandomAnalogValueObject( objectIdentifier=('analogValue', 1), objectName='Random1', eventMessageTexts=ArrayOf(CharacterString)(["hello"]), ) _log.debug(" - ravo1: %r", ravo1) ravo2 = RandomAnalogValueObject(objectIdentifier=('analogValue', 2), objectName='Random2') _log.debug(" - ravo2: %r", ravo2) # add it to the device this_application.add_object(ravo1) this_application.add_object(ravo2) _log.debug(" - object list: %r", this_device.objectList) # get the services supported services_supported = this_application.get_services_supported() if _debug: _log.debug(" - services_supported: %r", services_supported) # let the device object know this_device.protocolServicesSupported = services_supported.value _log.debug("running") run() _log.debug("fini")
def __init__( self, bacpypes_inifile, brickbacnet_config, sqlite_db, ): self.logger = logging.getLogger('bacnet_discovery') self.logger.setLevel(logging.WARNING) config = configparser.ConfigParser() config.read(bacpypes_inifile) config = config["BACpypes"] self.address_mask = config["address"] # TODO: What does this do? self.this_device = LocalDeviceObject( objectName=config["objectName"], objectIdentifier=int(config["objectIdentifier"]), maxApduLengthAccepted=int(config["maxApduLengthAccepted"]), segmentationSupported=config["segmentationSupported"], vendorIdentifier=int(config["vendorIdentifier"]), vendorName="brick-community", ) self.sqlite_db = sqlite_db BIPSimpleApplication.__init__(self, self.this_device, config["address"]) self.taskman = TaskManager() self.object_custom_fields = brickbacnet_config['object_custom_fields']
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # create a thread and read_thread = ReadPointListThread(point_list) if _debug: _log.debug(" - read_thread: %r", read_thread) # start it running when the core is running deferred(read_thread.start) _log.debug("running") run() # dump out the results for request, response in zip(point_list, read_thread.response_values): print(request, response) _log.debug("fini")
def main(): global vendor_id # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a sample application this_application = BIPSimpleApplication(this_device, args.ini.address) # make some objects ravo1 = VendorAVObject(objectIdentifier=(513, 1), objectName='Random1') if _debug: _log.debug(" - ravo1: %r", ravo1) ravo2 = VendorAVObject(objectIdentifier=(513, 2), objectName='Random2') if _debug: _log.debug(" - ravo2: %r", ravo2) # add it to the device this_application.add_object(ravo1) this_application.add_object(ravo2) if _debug: _log.debug(" - object list: %r", this_device.objectList) if _debug: _log.debug("running") run() if _debug: _log.debug("fini")
def main(): global this_device global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a simple application this_application = WhoIsIAmApplication(this_device, args.ini.address) this_application.i_am() _log.debug("running") run() stop() _log.debug("fini")
def main(): global args, this_application # parse the command line arguments parser = ConfigArgumentParser(description=__doc__) # add an option to override the interval time parser.add_argument( '--interval', type=float, help="amount of time between intervals", default=INTERVAL, ) # parse the command line arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = ReadPointListApplication(this_device, args.ini.address) _log.debug("running") run() _log.debug("fini")
def __init__(self, test_name): if _debug: ApplicationNetwork._debug("__init__ %r", test_name) StateMachineGroup.__init__(self) # reset the time machine reset_time_machine() if _debug: ApplicationNetwork._debug(" - time machine reset") # create a traffic log self.traffic_log = TrafficLog() # make a little LAN self.vlan = Network(broadcast_address=LocalBroadcast()) self.vlan.traffic_log = self.traffic_log # test device object self.td_device_object = LocalDeviceObject( objectName="td", objectIdentifier=("device", 10), maxApduLengthAccepted=1024, segmentationSupported="noSegmentation", vendorIdentifier=999, ) # test device self.td = ApplicationStateMachine(self.td_device_object, self.vlan) self.append(self.td) # error device generates bad packets self.ed = ApplicationLayerStateMachine(20, self.vlan) self.append(self.ed)
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = ReadPointListApplication(point_list, this_device, args.ini.address) # fire off a request when the core has a chance deferred(this_application.next_request) _log.debug("running") run() # dump out the results for request, response in zip(point_list, this_application.response_values): print(request, response) _log.debug("fini")
def __init__(self, sensor_id: int, vlan_address: Address) -> None: vlan_device = LocalDeviceObject( objectName="Sensor %d" % (sensor_id,), objectIdentifier=("device", sensor_id), maxApduLengthAccepted=1024, segmentationSupported="segmentedBoth", vendorIdentifier=15, ) if _debug: Sensor._debug(" - vlan_device: %r", vlan_device) if _debug: Sensor._debug(" - vlan_address: %r", vlan_address) # make the application _VLANApplication.__init__(self, vlan_device, vlan_address) if _debug: Sensor._debug(" - vlan_app: %r", self) self._id = sensor_id self._vlan_address = vlan_address self._object_index = 0 self._objects: Dict[str, Any] = {} self._last_updated: float = 0 self._fault = False
def getData(collection): global this_application, device_address, object_identifier, property_list # 清空数组 global result, tag_list, tag_keys, count print collection result = [] tag_list = [] tag_keys = {} count = 0 parser = ConfigArgumentParser(description=__doc__) args = parser.parse_args() tag_list = collection["bacnet_items"] try: this_device = LocalDeviceObject(ini=args.ini) this_application = ReadPropertyApplication(this_device, args.ini.address) deferred(this_application.requests) run() this_application.close_socket() except Exception as e: print str(e) return {"data": "采集失败", "success": "false"} import datetime dt = datetime.datetime.now() timestamp = dt.strftime("%Y-%m-%d %H:%M:%S") for item in tag_keys: result.append({ "timestamp": timestamp, "value": None, "item": tag_keys[item]['tag'], "quality": "Error" }) return {"data": result, "success": "true"}
def __init__(self, ini_file, overriding_port: int = None): self.args = ConfigArgumentParser().parse_args(["--ini", ini_file]) #addr = Address(self.args.ini.address) #if overriding_port: # addr.addrPort = overriding_port #print('Address: {0}'.format(addr.addrPort)) if overriding_port: ip, port = self.args.ini['address'].split(':') self.args.ini['address'] = ip + ':' + str(overriding_port) self.this_device = LocalDeviceObject(ini=self.args.ini) BIPSimpleApplication.__init__(self, self.this_device, self.args.ini['address']) self.taskman = TaskManager() self.datatype_map = { 'b': Boolean, 'u': lambda x: Unsigned(int(x)), 'i': lambda x: Integer(int(x)), 'r': lambda x: Real(float(x)), 'd': lambda x: Double(float(x)), 'o': OctetString, 'c': CharacterString, 'bs': BitString, 'date': Date, 'time': Time, 'id': ObjectIdentifier, } thread_handle = threading.Thread(target=self.run_thread) thread_handle.daemon = True thread_handle.start()
def main(): # make a device object this_device = LocalDeviceObject(objectName=config.bacnet_device['object_name'], objectIdentifier=config.bacnet_device['object_identifier'], maxApduLengthAccepted=config.bacnet_device['max_apdu_length_accepted'], segmentationSupported=config.bacnet_device['segmentation_supported'], vendorIdentifier=config.bacnet_device['vendor_identifier'], ) # point list, set according to your device point_list = [ # point_id, addr, obj_type, obj_inst, prop_id, idx (1, '10.117.73.53', 'analogInput', 1, 'presentValue', None), (2, '10.117.73.53', 'analogInput', 2, 'presentValue', None), (3, '10.117.73.53', 'analogInput', 3, 'presentValue', None), (4, '10.117.73.53', 'analogInput', 4, 'presentValue', None), (5, '10.117.73.53', 'analogInput', 5, 'presentValue', None), (6, '10.117.73.53', 'analogInput', 6, 'presentValue', None), ] # make a simple application this_application = MyEMSApplication(point_list, this_device, config.bacnet_device['local_address'], Address(config.bacnet_device['foreignBBMD']), int(config.bacnet_device['foreignTTL'])) # fire off a request when the core has a chance deferred(this_application.next_request) run() # dump out the results for request, response in zip(point_list, this_application.response_values): print(request, response)
def main(): global this_application # check the version if (sys.version_info[:2] != (2, 5)): sys.stderr.write("Python 2.5 only\n") sys.exit(1) # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # make a console this_console = ReadPropertyConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): # make a device object gateway_device = LocalDeviceObject( objectName='GoogleIoTCollector', objectIdentifier=int(599), maxApduLengthAccepted=int(1024), segmentationSupported='segmentedBoth', vendorIdentifier=int(15), ) # Interval to read points read_interval = int(60) # Make Runner # Docker specific for running in container # Docker uses eth0. Allows us to dynamically pull interface = netifaces.ifaddresses('eth0')[2][0] address = interface['addr'] subnet = interface['netmask'] cidr_not = sum([bin(int(x)).count("1") for x in subnet.split(".")]) bacnet_address = str(address) + '/' + str(cidr_not) print('Address: {}, Subnet: {}, CIDR: {}, Bacnet: {}'.format( address, subnet, cidr_not, bacnet_address)) bacnet_app = BacnetRunner(read_interval, gateway_device, bacnet_address) # pylint: disable=W0612 run()
def main(): global vendor_id # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a sample application this_application = BIPSimpleApplication(this_device, args.ini.address) # create the objects and add them to the application create_objects(this_application) # run this update when the stack is ready deferred(update_weather_data) if _debug: _log.debug("running") run() if _debug: _log.debug("fini")
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # make a console this_console = ReadWritePropertyConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def __init__(self, template, template_directory, args): self.dom = etree.parse(template) device_info_root = self.dom.xpath("//bacnet/device_info")[0] name_key = device_info_root.xpath("./device_name/text()")[0] id_key = device_info_root.xpath("./device_identifier/text()")[0] vendor_name_key = device_info_root.xpath("./vendor_name/text()")[0] vendor_identifier_key = device_info_root.xpath( "./vendor_identifier/text()")[0] apdu_length_key = device_info_root.xpath( "./max_apdu_length_accepted/text()")[0] segmentation_key = device_info_root.xpath( "./segmentation_supported/text()")[0] self.thisDevice = LocalDeviceObject( objectName=name_key, objectIdentifier=int(id_key), maxApduLengthAccepted=int(apdu_length_key), segmentationSupported=segmentation_key, vendorName=vendor_name_key, vendorIdentifier=int(vendor_identifier_key), ) self.bacnet_app = None self.server = None # Initialize later logger.info("Conpot Bacnet initialized using the %s template.", template)
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object mstp_args = { '_address': int(args.ini.address), '_interface': str(args.ini.interface), '_max_masters': int(args.ini.max_masters), '_baudrate': int(args.ini.baudrate), '_maxinfo': int(args.ini.maxinfo), } this_device = LocalDeviceObject(ini=args.ini, **mstp_args) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = MSTPSimpleApplication(this_device, args.ini.address) # make a console this_console = ReadPropertyMultipleConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): global this_device, this_application, saved_recipent_list # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = EventNotificationApplication( this_device, args.ini.address, ) if _debug: _log.debug(" - this_application: %r", this_application) # make a console this_console = EventNotificationConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): global this_device, this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a simple application this_application = WhoIsIAmApplication( this_device, args.ini.address, Address(args.ini.foreignbbmd), int(args.ini.foreignttl), ) if _debug: _log.debug(" - this_application: %r", this_application) # make a console this_console = WhoIsIAmConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a sample application this_application = BIPSimpleApplication(this_device, args.ini.address) # make a multistate value object msvo = MultiStateValueObject( objectIdentifier=('multiStateValue', 1), objectName='My Special Object', presentValue=1, numberOfStates=3, stateText=['red', 'green', 'blue'], ) _log.debug(" - msvo: %r", msvo) # add it to the device this_application.add_object(msvo) _log.debug(" - object list: %r", this_device.objectList) _log.debug("running") run() _log.debug("fini")
def configure(self, context): super().configure(context) # bacnet device config self.ldo = LocalDeviceObject(objectName=self.name(), objectIdentifier=int(self.id()), maxApduLengthAccepted=int( self.max_apdu_length()), segmentationSupported=self.segmentation(), vendorIdentifier=int(self.vendor_id())) # Send an empty support string pss = ServicesSupported() ldo.protocolServicesSupported = pss.value info = self.address() hostname = "" for i, c in enumerate(info): if c is '/' or c is ':': break hostname += c suffix = info[i:] addr = socket.gethostbyname(hostname) self.this_application = SimpleApplication(self.ldo, addr + suffix)
def main(): # parse the command line arguments parser = ConfigArgumentParser(description=__doc__) # add an argument for interval parser.add_argument( 'interval', type=int, help='repeat rate in seconds', ) # now parse the arguments args = parser.parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject(ini=args.ini) if _debug: _log.debug(" - this_device: %r", this_device) # make a dog this_application = PrairieDog(args.interval, this_device, args.ini.address) if _debug: _log.debug(" - this_application: %r", this_application) _log.debug("running") run() _log.debug("fini")
def main(): global this_application # parse the command line arguments args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), ) # make a simple application this_application = BIPSimpleApplication(this_device, args.ini.address) # make a console this_console = DCCConsoleCmd() if _debug: _log.debug(" - this_console: %r", this_console) # enable sleeping will help with threads enable_sleeping() _log.debug("running") run() _log.debug("fini")
def main(): # parse the command line arguments and initialize loggers args = ConfigArgumentParser(description=__doc__).parse_args() if _debug: _log.debug("initialization") if _debug: _log.debug(" - args: %r", args) # make a device object this_device = LocalDeviceObject( objectName=args.ini.objectname, objectIdentifier=int(args.ini.objectidentifier), maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted), segmentationSupported=args.ini.segmentationsupported, vendorIdentifier=int(args.ini.vendoridentifier), vendorName="B612", ) # make a sample application this_application = SampleApplication(this_device, args.ini.address) if _debug: _log.debug(" - this_application: %r", this_application) _log.debug("running") run() _log.debug("fini")