Problem, ein Befehl startet automatisch, wenn die Anwendungen

Question

startet, so dass ich versuche, sowohl Python und BACnet mit der BACpypes-Bibliothek zu lernen, und ich bin ein wenig stecken jetzt.

Ich versuche, die "WhoIs-IAm" Beispielanwendung, um eine automatische "IAm" Broadcast zu tun, wenn gestartet, aber in Bezug auf meine Anfänger Fähigkeit habe ich Probleme, es zu bauen.

So gibt es das Beispiel.

#!/usr/bin/python 
 

 
""" 
 
This application presents a 'console' prompt to the user asking for Who-Is and I-Am 
 
commands which create the related APDUs, then lines up the coorresponding I-Am 
 
for incoming traffic and prints out the contents. 
 
""" 
 

 
import sys 
 

 
from bacpypes.debugging import bacpypes_debugging, ModuleLogger 
 
from bacpypes.consolelogging import ConfigArgumentParser 
 
from bacpypes.consolecmd import ConsoleCmd 
 

 
from bacpypes.core import run 
 

 
from bacpypes.pdu import Address, GlobalBroadcast 
 
from bacpypes.app import LocalDeviceObject, BIPSimpleApplication 
 

 
from bacpypes.apdu import WhoIsRequest, IAmRequest 
 
from bacpypes.basetypes import ServicesSupported 
 
from bacpypes.errors import DecodingError 
 

 
# some debugging 
 
_debug = 0 
 
_log = ModuleLogger(globals()) 
 

 
# globals 
 
this_device = None 
 
this_application = None 
 
this_console = None 
 

 
# 
 
# WhoIsIAmApplication 
 
# 
 

 
class WhoIsIAmApplication(BIPSimpleApplication): 
 

 
    def __init__(self, *args): 
 
     if _debug: WhoIsIAmApplication._debug("__init__ %r", args) 
 
     BIPSimpleApplication.__init__(self, *args) 
 

 
     # keep track of requests to line up responses 
 
     self._request = None 
 

 
    def request(self, apdu): 
 
     if _debug: WhoIsIAmApplication._debug("request %r", apdu) 
 

 
     # save a copy of the request 
 
     self._request = apdu 
 

 
     # forward it along 
 
     BIPSimpleApplication.request(self, apdu) 
 

 
    def confirmation(self, apdu): 
 
     if _debug: WhoIsIAmApplication._debug("confirmation %r", apdu) 
 

 
     # forward it along 
 
     BIPSimpleApplication.confirmation(self, apdu) 
 

 
    def indication(self, apdu): 
 
     if _debug: WhoIsIAmApplication._debug("indication %r", apdu) 
 

 
     if (isinstance(self._request, WhoIsRequest)) and (isinstance(apdu, IAmRequest)): 
 
      device_type, device_instance = apdu.iAmDeviceIdentifier 
 
      if device_type != 'device': 
 
       raise DecodingError, "invalid object type" 
 

 
      if (self._request.deviceInstanceRangeLowLimit is not None) and \ 
 
       (device_instance < self._request.deviceInstanceRangeLowLimit): 
 
       pass 
 
      elif (self._request.deviceInstanceRangeHighLimit is not None) and \ 
 
       (device_instance > self._request.deviceInstanceRangeHighLimit): 
 
       pass 
 
      else: 
 
       # print out the contents 
 
       sys.stdout.write('pduSource = ' + repr(apdu.pduSource) + '\n') 
 
       sys.stdout.write('iAmDeviceIdentifier = ' + str(apdu.iAmDeviceIdentifier) + '\n') 
 
       sys.stdout.write('maxAPDULengthAccepted = ' + str(apdu.maxAPDULengthAccepted) + '\n') 
 
       sys.stdout.write('segmentationSupported = ' + str(apdu.segmentationSupported) + '\n') 
 
       sys.stdout.write('vendorID = ' + str(apdu.vendorID) + '\n') 
 
       sys.stdout.flush() 
 

 
     # forward it along 
 
     BIPSimpleApplication.indication(self, apdu) 
 

 
bacpypes_debugging(WhoIsIAmApplication) 
 

 
# 
 
# WhoIsIAmConsoleCmd 
 
# 
 

 
class WhoIsIAmConsoleCmd(ConsoleCmd): 
 

 
    def do_whois(self, args): 
 
     """whois [ <addr>] [ <lolimit> <hilimit> ]""" 
 
     args = args.split() 
 
     if _debug: WhoIsIAmConsoleCmd._debug("do_whois %r", args) 
 

 
     try: 
 
      # build a request 
 
      request = WhoIsRequest() 
 
      if (len(args) == 1) or (len(args) == 3): 
 
       request.pduDestination = Address(args[0]) 
 
       del args[0] 
 
      else: 
 
       request.pduDestination = GlobalBroadcast() 
 

 
      if len(args) == 2: 
 
       request.deviceInstanceRangeLowLimit = int(args[0]) 
 
       request.deviceInstanceRangeHighLimit = int(args[1]) 
 
      if _debug: WhoIsIAmConsoleCmd._debug(" - request: %r", request) 
 

 
      # give it to the application 
 
      this_application.request(request) 
 

 
     except Exception, e: 
 
      WhoIsIAmConsoleCmd._exception("exception: %r", e) 
 

 
    def do_iam(self, args): 
 
     """iam""" 
 
     args = args.split() 
 
     if _debug: WhoIsIAmConsoleCmd._debug("do_iam %r", args) 
 

 
     try: 
 
      # build a request 
 
      request = IAmRequest() 
 
      request.pduDestination = GlobalBroadcast() 
 

 
      # set the parameters from the device object 
 
      request.iAmDeviceIdentifier = this_device.objectIdentifier 
 
      request.maxAPDULengthAccepted = this_device.maxApduLengthAccepted 
 
      request.segmentationSupported = this_device.segmentationSupported 
 
      request.vendorID = this_device.vendorIdentifier 
 
      if _debug: WhoIsIAmConsoleCmd._debug(" - request: %r", request) 
 

 
      # give it to the application 
 
      this_application.request(request) 
 

 
     except Exception, e: 
 
      WhoIsIAmConsoleCmd._exception("exception: %r", e) 
 

 
    def do_rtn(self, args): 
 
     """rtn <addr> <net> ... """ 
 
     args = args.split() 
 
     if _debug: WhoIsIAmConsoleCmd._debug("do_rtn %r", args) 
 

 
     # safe to assume only one adapter 
 
     adapter = this_application.nsap.adapters[0] 
 
     if _debug: WhoIsIAmConsoleCmd._debug(" - adapter: %r", adapter) 
 

 
     # provide the address and a list of network numbers 
 
     router_address = Address(args[0]) 
 
     network_list = [int(arg) for arg in args[1:]] 
 

 
     # pass along to the service access point 
 
     this_application.nsap.add_router_references(adapter, router_address, network_list) 
 

 
bacpypes_debugging(WhoIsIAmConsoleCmd) 
 

 
# 
 
# __main__ 
 
# 
 

 
try: 
 
    # 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), 
 
     ) 
 

 
    # 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) 
 

 
    # 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() 
 

 
    _log.debug("running") 
 

 
    run() 
 

 
except Exception, e: 
 
    _log.exception("an error has occurred: %s", e) 
 
finally: 
 
    _log.debug("finally")

Ich weiß nur nicht, wie man die do_iam anrufen, damit es automatisch, wenn die App startet beginnt.

Irgendwelche Hilfe?

Danke.

Answer 1

Nach der Zeile this_console = WhoIsIAmConsoleCmd(), können Sie this_console.do_iam('') schreiben?