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)
# make an IOCB
iocb = IOCB(request)
if _debug: WhoIsIAmConsoleCmd._debug(" - iocb: %r", iocb)
# give it to the application
this_application.request_io(iocb)
except Exception as err:
WhoIsIAmConsoleCmd._exception("exception: %r", err)
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)
# make an IOCB
iocb = IOCB(request)
if _debug: WriteSomethingConsoleCmd._debug(" - iocb: %r", iocb)
# give it to the application
this_application.request_io(iocb)
except Exception as err:
WhoIsIAmConsoleCmd._exception("exception: %r", err)
def do_whois(self, addr=None, lolimit=None, hilimit=None):
"""whois [ <addr>] [ <lolimit> <hilimit> ]"""
try:
# build a request
request = WhoIsRequest()
if (addr is None):
request.pduDestination = GlobalBroadcast()
else:
request.pduDestination = Address(addr)
if lolimit is not None:
request.deviceInstanceRangeLowLimit = int(lolimit)
if hilimit is not None:
request.deviceInstanceRangeHighLimit = int(hilimit)
if _debug: logger.debug(" - request: %r", request)
# make an IOCB
iocb = IOCB(request)
if _debug: logger.debug(" - iocb: %r", iocb)
# give it to the application
self.request_io(iocb)
except Exception as err:
logger.debug("exception: %r", err)
def do_whois(self, args):
if _debug: ThreadedHTTPRequestHandler._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: ThreadedHTTPRequestHandler._debug(" - request: %r", request)
# make an IOCB
iocb = IOCB(request)
if _debug: ThreadedHTTPRequestHandler._debug(" - iocb: %r", iocb)
# give it to the application
this_application.request_io(iocb)
# no result -- it would be nice if these were the matching I-Am's
result = {}
except Exception as err:
ThreadedHTTPRequestHandler._exception("exception: %r", err)
result = { "exception": str(err) }
# write the result
json.dump(result, self.wfile)
def whois_request(args, console=None):
"""
This function creates a whois request.
Usage: whois [ <address> ] [ <lowlimit> <highlimit> ]
:param args: list of parameters
:param console: console object
:return: request
"""
# create request
request = WhoIsRequest()
# check if address was set
if len(args) in (1, 3):
request.pduDestination = Address(args[0])
del args[0]
# send broadcast otherwise
else:
request.pduDestination = GlobalBroadcast()
# check if limits were set
if len(args) == 2:
request.deviceInstanceRangeLowLimit = int(args[0])
request.deviceInstanceRangeHighLimit = int(args[0])
# return created request
return request
def do_whois(self, args):
"""whois [ <addr> ] [ <lolimit> <hilimit> ]"""
args = args.split()
if _debug: TestConsoleCmd._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:
loLimit = int(args[0])
hiLimit = int(args[1])
request.deviceInstanceRangeLowLimit = int(args[0])
request.deviceInstanceRangeHighLimit = int(args[1])
if _debug: TestConsoleCmd._debug(" - request: %r", request)
# give it to the application
this_application.Request(request)
except Exception, e:
TestConsoleCmd._exception("exception: %r", e)
def whois(self, *args, global_broadcast=False):
"""
Build a WhoIs request
:param args: string built as [ <addr>] [ <lolimit> <hilimit> ] **optional**
:returns: discoveredDevices as a defaultdict(int)
Example::
whois(global_broadcast=True) # WhoIs broadcast globally. Every device will respond with an IAm
whois('2:5') # WhoIs looking for the device at (Network 2, Address 5)
whois('10 1000') # WhoIs looking for devices in the ID range (10 - 1000)
"""
if not self._started:
raise ApplicationNotStarted(
"BACnet stack not running - use startApp()")
if args:
args = args[0].split()
msg = args if args else "any"
self._log.debug("do_whois {!r}".format(msg))
# build a request
request = WhoIsRequest()
if (len(args) == 1) or (len(args) == 3):
request.pduDestination = Address(args[0])
del args[0]
else:
if global_broadcast:
request.pduDestination = GlobalBroadcast()
else:
request.pduDestination = LocalBroadcast()
if len(args) == 2:
try:
request.deviceInstanceRangeLowLimit = int(args[0])
request.deviceInstanceRangeHighLimit = int(args[1])
except ValueError:
pass
self._log.debug("{:>12} {}".format("- request:", request))
iocb = IOCB(request) # make an IOCB
self.this_application._last_i_am_received = []
# pass to the BACnet stack
deferred(self.this_application.request_io, iocb)
iocb.wait() # Wait for BACnet response
if iocb.ioResponse: # successful response
apdu = iocb.ioResponse
if iocb.ioError: # unsuccessful: error/reject/abort
pass
time.sleep(3)
self.discoveredDevices = self.this_application.i_am_counter
return self.this_application._last_i_am_received
def whois(self, *args):
"""
Build a WhoIs request
:param args: string built as [ <addr>] [ <lolimit> <hilimit> ] **optional**
:returns: discoveredDevices as a defaultdict(int)
Example::
whois() # WhoIs broadcast globally. Every device will respond with an IAm
whois('2:5') # WhoIs looking for the device at (Network 2, Address 5)
whois('10 1000') # WhoIs looking for devices in the ID range (10 - 1000)
"""
if not self._started:
raise ApplicationNotStarted("BACnet stack not running - use startApp()")
if args:
args = args[0].split()
msg = args if args else "any"
self._log.debug("do_whois {!r}".format(msg))
# 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])
self._log.debug("{:>12} {}".format("- request:", request))
iocb = IOCB(request) # make an IOCB
# pass to the BACnet stack
self.this_application.request_io(iocb)
iocb.wait() # Wait for BACnet response
if iocb.ioResponse: # successful response
apdu = iocb.ioResponse
if iocb.ioError: # unsuccessful: error/reject/abort
pass
self.discoveredDevices = self.this_application.i_am_counter
return self.discoveredDevices
def whois(self, *args):
"""
Creation of a whois requests
Requets is given to the app
:param args: string built as [ <addr>] [ <lolimit> <hilimit> ] **optional**
:returns: discoveredDevices as a defaultdict(int)
Example::
whois()
#will create a broadcast whois request and every device will response by a Iam
whois('2:5')
#will create a whois request aimed at device 5
whois('10 1000')
#will create a whois request looking for device ID 10 to 1000
"""
if args:
args = args[0].split()
if not args:
msg = "any"
else:
msg = args
log_debug("do_whois %r" % msg)
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])
log_debug(" - request: %r" % request)
# give it to the application
self.this_application.request(request)
except Exception as error:
log_exception("exception: %r" % error)
self.discoveredDevices = self.this_application.i_am_counter
return self.discoveredDevices
def get_iam(app, device_id, target_address = None):
request = WhoIsRequest()
request.deviceInstanceRangeLowLimit = device_id
request.deviceInstanceRangeHighLimit = device_id
if target_address is not None:
request.pduDestination = Address(target_address)
else:
request.pduDestination = GlobalBroadcast()
result = app.make_request(request, expected_device_id=device_id)
return result
def get_iam(app, device_id, target_address = None):
request = WhoIsRequest()
request.deviceInstanceRangeLowLimit = device_id
request.deviceInstanceRangeHighLimit = device_id
if target_address is not None:
request.pduDestination = Address(target_address)
else:
request.pduDestination = GlobalBroadcast()
result = app.make_request(request, expected_device_id=device_id)
return result
def get_device(self, address):
"""
This function returns device identifier if known.
:param address: device address
:return: device identifier
"""
# check if address is known
if not 'id' in self.known_devices.get(address, {}):
# create request
request = WhoIsRequest()
# set destination to address
request.pduDestination = Address(address)
self._debug(' - request: %s', request)
# queue request
self.requests.put(request)
# exit
return
# get device
device = self.known_devices[address]
# return device
return device['id']
def broadcast():
try:
device_list = list()
localaddress = list()
ips = getIPs()
print "found local ip as ", ips
for ip in ips:
str(ip)
localaddress = ip + "/24"
# make a device object
this_device = LocalDeviceObject(
objectName="BEMOSS",
objectIdentifier=
599, #change if there exists a bacnet device with same identifier
maxApduLengthAccepted=1024,
segmentationSupported="segmentedBoth",
vendorIdentifier=99,
)
# Device application
this_application = Application(this_device, localaddress)
request = WhoIsRequest()
request.pduDestination = GlobalBroadcast()
def time_out():
time.sleep(5)
stop()
thread = threading.Thread(target=time_out)
thread.start()
this_application.request(request)
this_application.found_address = list()
this_application.found_deviceidentifier = list()
run()
#time.sleep(10)
this_application.release = True
this_application.update = False
address, deviceidentifier = this_application.updator()
todelete = list()
for i in range(0, len(deviceidentifier)):
if deviceidentifier[i] == 0:
todelete.append(i)
for i in todelete:
del address[i], deviceidentifier[
i] #Deleting identified bacnet router
Remote_address = list(set(address)) #Removing repeatition
Identifier = list(set(deviceidentifier)) #Removing repeatition
print "destination address list is ", Remote_address
print "object instance of that address", Identifier
return this_application, Remote_address, Identifier
except Exception, e:
_log.exception("an error has occurred: %s", e)
return None
def ping_device(self, target_address):
"""Ping a device with a whois to potentially setup routing."""
request = WhoIsRequest()
request.pduDestination = Address(target_address)
iocb = IOCB(request, self.async_call)
self.this_application.submit_request(iocb)
def ping_device(self, target_address):
"""Ping a device with a whois to potentially setup routing."""
request = WhoIsRequest()
request.pduDestination = Address(target_address)
iocb = IOCB(request, self.async_call)
self.this_application.submit_request(iocb)
def who_is(self, low_device_id=None, high_device_id=None, target_address=None):
_log.debug("Sending WhoIs: low_id: {low} high: {high} address: {address}".format(
low=low_device_id, high=high_device_id, address=target_address))
request = WhoIsRequest()
if low_device_id is not None:
request.deviceInstanceRangeLowLimit = low_device_id
if high_device_id is not None:
request.deviceInstanceRangeHighLimit = high_device_id
if target_address is not None:
request.pduDestination = Address(target_address)
else:
request.pduDestination = GlobalBroadcast()
iocb = self.iocb_class(request)
self.bacnet_application.submit_request(iocb)
def whois(self, *args):
"""
Creation of a whois requests
Requets is given to the app
:param args: string built as [ <addr>] [ <lolimit> <hilimit> ] **optional**
:returns: discoveredDevices as a defaultdict(int)
Example::
whois()
#will create a broadcast whois request and every device will response by a Iam
whois('2:5')
#will create a whois request aimed at device 5
whois('10 1000')
#will create a whois request looking for device ID 10 to 1000
"""
if args:
args = args[0].split()
if _debug: WhoisIAm._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: WhoisIAm._debug(" - request: %r" % request)
# give it to the application
self.this_application.request(request)
except Exception as e:
WhoisIAm._exception("exception: %r" % e)
self.discoveredDevices = self.this_application.i_am_counter
return self.discoveredDevices
def ping_target(self, address):
#Some devices (mostly RemoteStation addresses behind routers) will not be reachable without
# first establishing the route to the device. Sending a directed WhoIsRequest is will
# settle that for us when the response comes back.
request = WhoIsRequest()
request.pduDestination = address
iocb = IOCB(request)
this_application.submit_request(iocb)
def ping_device(self, target_address, device_id):
"""Ping a device with a whois to potentially setup routing."""
_log.debug("Pinging " + target_address)
request = WhoIsRequest()
request.deviceInstanceRangeLowLimit = device_id
request.deviceInstanceRangeHighLimit = device_id
request.pduDestination = GlobalBroadcast()
iocb = IOCB(request, self.async_call)
self.this_application.submit_request(iocb)
def ping_target(self, address):
#Some devices (mostly RemoteStation addresses behind routers) will not be reachable without
# first establishing the route to the device. Sending a directed WhoIsRequest is will
# settle that for us when the response comes back.
request = WhoIsRequest()
request.pduDestination = address
iocb = IOCB(request)
this_application.submit_request(iocb)
def who_is(self, low_device_id=None, high_device_id=None, target_address=None):
_log.debug("Sending WhoIs: low_id: {low} high: {high} address: {address}".format(low=low_device_id,
high=high_device_id,
address=target_address))
request = WhoIsRequest()
if low_device_id is not None:
request.deviceInstanceRangeLowLimit = low_device_id
if high_device_id is not None:
request.deviceInstanceRangeHighLimit = high_device_id
if target_address is not None:
request.pduDestination = Address(target_address)
else:
request.pduDestination = GlobalBroadcast()
iocb = self.iocb_class(request)
self.this_application.submit_request(iocb)
def do_whois(self, device=None):
try:
device = {} if device is None else device
request = WhoIsRequest()
address = device.get("address")
low_limit = device.get("idLowLimit")
high_limit = device.get("idHighLimit")
if address is not None:
request.pduDestination = Address(address)
else:
request.pduDestination = GlobalBroadcast()
if low_limit is not None and high_limit is not None:
request.deviceInstanceRangeLowLimit = int(low_limit)
request.deviceInstanceRangeHighLimit = int(high_limit)
iocb = IOCB(request)
deferred(self.request_io, iocb)
except Exception as e:
log.exception(e)
def do_whois(self, address=None, lowlimit=None, highlimit=None):
"""whois [ <addr>] [ <lolimit> <hilimit> ]"""
if _debug: self._debug("do_whois %r", (address, lowlimit, highlimit))
try:
# build a request
request = WhoIsRequest()
if address != None:
request.pduDestination = Address(address)
else:
request.pduDestination = GlobalBroadcast()
if address == None and isinstance(lowlimit, int) and isinstance(
highlimit(int)):
request.deviceInstanceRangeLowLimit = int(lowlimit)
request.deviceInstanceRangeHighLimit = int(highlimit)
if _debug: self._debug(" - request: %r", request)
# make an IOCB
iocb = IOCB(request)
if _debug: self._debug(" - iocb: %r", iocb)
# give it to the application
self.request_io(iocb)
# build a key from the source and parameters
key = (
str(request.pduSource),
request.deviceInstanceRangeLowLimit,
request.deviceInstanceRangeHighLimit,
)
try:
self.whois_counter[key] += 1
except KeyError:
self.whois_counter[key] = 1
except Exception as err:
self._exception("exception: %r", err)
def do_whois(self, args):
"""whois [ <addr>] [ <lolimit> <hilimit> ]"""
args = args.split()
if _debug: BacnetConsoleCmd._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: BacnetConsoleCmd._debug(" - request: %r", request)
# give it to the application
thisApplication.request(request)
except Exception, e:
BacnetConsoleCmd._exception("exception: %r", e)
def do_whois(self, args):
"""
whois [ <addr> ] [ <lolimit> <hilimit> ]
Send a Who-Is Request and wait 3 seconds for the I-Am "responses" to
be returned.
"""
args = args.split()
if _debug: DiscoverConsoleCmd._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: DiscoverConsoleCmd._debug(" - request: %r", request)
# make an IOCB
iocb = IOCB(request)
if _debug: DiscoverConsoleCmd._debug(" - iocb: %r", iocb)
# give it to the application
deferred(this_application.request_io, iocb)
# sleep for responses
time.sleep(3.0)
except Exception as err:
DiscoverConsoleCmd._exception("exception: %r", err)
def discover_devices(self, timeout=5):
""" Send a WhoIsRequest and wait for timeout seconds to receive all responses. """
self.devices = {}
req = WhoIsRequest(
) # How does this know it needs to store at devices?
req.pduDestination = Address(
"255.255.255.255") # Global Broadcast address
iocb = IOCB(req)
self.request_io(iocb)
iocb.set_timeout(5)
iocb.wait()
time.sleep(
timeout) # wait for 5 seconds so all the responses are received.
self.update_device_metadata(self.devices)
return self.devices
def broadcast(self,sender,topic,message):
try:
return_pipe = self.extract_pipe(message["reduced_return_pipe"])
request = WhoIsRequest()
request.pduDestination = GlobalBroadcast()
self.this_application.request(request)
self.this_application.release = True
self.this_application.update = False
addresslist = self.this_application.found_address
addresslist=list(set(addresslist))
#self.bemoss_publish(target=sender,topic='broadcast_response',message=addresslist)
print "Printing address"
print addresslist
return_pipe.send(addresslist)
except Exception as e:
_log.exception("an error has occurred during bacnet discovery: %s", e)
return []
def setup_device(self,
address,
max_apdu_len=1024,
seg_supported='segmentedBoth',
obj_id=599,
obj_name='sMap BACnet driver',
ven_id=15):
_log.info('seg_supported ' + str(seg_supported))
_log.info('max_apdu_len ' + str(max_apdu_len))
_log.info('obj_id ' + str(obj_id))
_log.info('obj_name ' + str(obj_name))
_log.info('ven_id ' + str(ven_id))
# Check to see if they gave a valid apdu length.
if encode_max_apdu_response(max_apdu_len) is None:
raise ValueError(
'Invalid max_apdu_len: {} Valid options are 50, 128, 206, 480, 1024, and 1476'
.format(max_apdu_len))
this_device = LocalDeviceObject(
objectName=obj_name,
objectIdentifier=obj_id,
maxApduLengthAccepted=max_apdu_len,
segmentationSupported=seg_supported,
vendorIdentifier=ven_id,
)
# build a bit string that knows about the bit names and leave it empty. We respond to NOTHING.
pss = ServicesSupported()
# set the property value to be just the bits
this_device.protocolServicesSupported = pss.value
self.this_application = BACnet_application(this_device, address)
server_thread = threading.Thread(target=bacpypes.core.run)
# exit the BACnet App thread when the main thread terminates
server_thread.daemon = True
request = WhoIsRequest()
request.pduDestination = GlobalBroadcast()
server_thread.start()
def broadcast(self):
try:
request = WhoIsRequest()
request.pduDestination = GlobalBroadcast()
self.this_application.request(request)
thread = threading.Thread(target=10)
self.this_application.request(request)
self.this_application.release = True
self.this_application.update = False
addresslist = self.this_application.found_address
addresslist = list(set(addresslist))
return addresslist
except Exception as e:
_log.exception("an error has occurred during bacnet discovery: %s",
e)
return []
def ping(self) -> None:
try:
# build a request
request = WhoIsRequest()
# ping all devices on network
request.pduDestination = GlobalBroadcast()
# make an IOCB (input output callback)
iocb = IOCB(request)
self.app.request_io(iocb)
self.logger.debug("ping: waiting for responses...")
loopCount = 0
while loopCount < 20 and not iocb.ioResponse:
loopCount += 1
run_once()
asyncore.loop(timeout=0.2, count=1)
time.sleep(0.2)
self.logger.debug(f"ping: loopy {loopCount}")
stop()
# handle responses
if iocb.ioResponse:
self.logger.debug(f"ping: iocb response success!")
apdu = iocb.ioResponse
if not isinstance(apdu, IAmRequest):
self.logger.error(f"ping: Not an IAmRequest")
return
device_type, device_instance = apdu.iAmDeviceIdentifier
if device_type != 'device':
raise DecodingError("ping: invalid object type")
self.logger.info(f"ping: pduSource={repr(apdu.pduSource)}")
self.logger.info(f"ping: deviceId={str(apdu.iAmDeviceIdentifier)}")
# do something for error/reject/abort
if iocb.ioError:
self.logger.error(f"ping: {str(iocb.ioError)}")
except Exception as err:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_tb(exc_traceback, file=sys.stdout)
self.logger.critical(f"ping: {err}")
def whois(self, *args):
"""
Build a WhoIs request
:param args: string built as [ <addr>] [ <lolimit> <hilimit> ] **optional**
:returns: discoveredDevices as a defaultdict(int)
Example::
whois() # WhoIs broadcast globally. Every device will respond with an IAm
whois('2:5') # WhoIs looking for the device at (Network 2, Address 5)
whois('10 1000') # WhoIs looking for devices in the ID range (10 - 1000)
"""
if not self._started:
raise ApplicationNotStarted('BACnet stack not running - use startApp()')
if args:
args = args[0].split()
msg = args if args else 'any'
log_debug(WhoisIAm, "do_whois %r" % msg)
# 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])
log_debug(WhoisIAm, " - request: %r" % request)
iocb = IOCB(request) # make an IOCB
self.this_application.request_io(iocb) # pass to the BACnet stack
iocb.wait() # Wait for BACnet response
if iocb.ioResponse: # successful response
apdu = iocb.ioResponse
# # should be an ack
# if not isinstance(apdu, IAmRequest) and not isinstance(apdu, WhoIsRequest):
# log_debug(WhoisIAm," - not an ack")
# return
# # find the datatype
# datatype = get_datatype(apdu.objectIdentifier[0], apdu.propertyIdentifier)
# log_debug(WhoisIAm," - datatype: %r", datatype)
# if not datatype:
# raise TypeError("unknown datatype")
#
# # special case for array parts, others are managed by cast_out
# if issubclass(datatype, Array) and (apdu.propertyArrayIndex is not None):
# if apdu.propertyArrayIndex == 0:
# value = apdu.propertyValue.cast_out(Unsigned)
# else:
# value = apdu.propertyValue.cast_out(datatype.subtype)
# else:
# value = apdu.propertyValue.cast_out(datatype)
# log_debug(WhoisIAm," - value: %r", value)
#
# if isinstance(apdu, IAmRequest):
# # build a key from the source, just use the instance number
# key = (str(apdu.pduSource),
# apdu.iAmDeviceIdentifier[1],)
# # count the times this has been received
# self.i_am_counter[key] += 1
#
# # Given an Who Is request, cache it.
# if isinstance(apdu, WhoIsRequest):
# # build a key from the source and parameters
# key = (str(apdu.pduSource),
# apdu.deviceInstanceRangeLowLimit,
# apdu.deviceInstanceRangeHighLimit,
# )
#
# # count the times this has been received
# self.who_is_counter[key] += 1
if iocb.ioError: # unsuccessful: error/reject/abort
pass
self.discoveredDevices = self.this_application.i_am_counter
return self.discoveredDevices
# build a bit string that knows about the bit names
pss = ServicesSupported()
pss['whoIs'] = 1
pss['iAm'] = 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)
_log.debug("running")
request = WhoIsRequest()
if args.address is not None:
request.pduDestination = Address(args.address)
else:
request.pduDestination = GlobalBroadcast()
if args.range is not None:
request.deviceInstanceRangeLowLimit = int(args.range[0])
request.deviceInstanceRangeHighLimit = int(args.range[1])
#set timeout timer
def time_out():
time.sleep(args.timeout)
stop()
thread = threading.Thread(target=time_out)
thread.start()
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 = SynchronousApplication(this_device, args.ini.address)
_log.debug("starting build")
target_address = Address(args.address)
request = WhoIsRequest()
request.pduDestination = target_address
result = this_application.make_request(request)
if not isinstance(result, IAmRequest):
result.debug_contents()
raise TypeError, "Error making WhoIs request"
device_type, device_instance = result.iAmDeviceIdentifier
if device_type != 'device':
raise DecodingError, "invalid object type"
_log.debug('pduSource = ' + repr(result.pduSource))
_log.debug('iAmDeviceIdentifier = ' + str(result.iAmDeviceIdentifier))
_log.debug('maxAPDULengthAccepted = ' + str(result.maxAPDULengthAccepted))
_log.debug('segmentationSupported = ' + str(result.segmentationSupported))
_log.debug('vendorID = ' + str(result.vendorID))
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 = SynchronousApplication(this_device, args.ini.address)
_log.debug("starting build")
target_address = Address(args.address)
request = WhoIsRequest()
request.pduDestination = target_address
result = this_application.make_request(request)
if not isinstance(result, IAmRequest):
result.debug_contents()
raise TypeError("Error making WhoIs request")
device_type, device_instance = result.iAmDeviceIdentifier
if device_type != 'device':
raise DecodingError("invalid object type")
_log.debug('pduSource = ' + repr(result.pduSource))
_log.debug('iAmDeviceIdentifier = ' + str(result.iAmDeviceIdentifier))
_log.debug('maxAPDULengthAccepted = ' + str(result.maxAPDULengthAccepted))
_log.debug('segmentationSupported = ' + str(result.segmentationSupported))
def do_whois(self, args):
NOT_IMPLEMENTED = True
if NOT_IMPLEMENTED:
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(NotImplementedError('WhoIs not implemented'))
return
if _debug:
HTTPRequestHandler._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:
HTTPRequestHandler._debug(" - request: %r", request)
# make an IOCB
iocb = IOCB(request)
timeout = int(self.headers.get('X-bacnet-timeout', 5))
iocb.set_timeout(timeout, err=TimeoutError)
if _debug:
HTTPRequestHandler._debug(" - iocb: %r", iocb)
# Give it to the application
deferred(this_application.request_io, iocb)
iocb.wait()
if iocb.ioError:
if _debug:
HTTPRequestHandler._debug(" - error: %r", iocb.ioError)
result = {"error": str(iocb.ioError)}
else:
if _debug:
HTTPRequestHandler._debug(
" - response: %r", iocb.ioResponse
)
apdu = iocb.ioResponse
# find the datatype
datatype = get_datatype(
apdu.objectIdentifier[0], apdu.propertyIdentifier
)
if _debug:
HTTPRequestHandler._debug(" - datatype: %r", datatype)
if not datatype:
raise TypeError("unknown datatype")
# special case for array parts, others are managed by cast_out
if issubclass(datatype, Array) and (
apdu.propertyArrayIndex is not None
):
if apdu.propertyArrayIndex == 0:
datatype = Unsigned
else:
datatype = datatype.subtype
if _debug:
HTTPRequestHandler._debug(
" - datatype: %r", datatype
)
# convert the value to a dict if possible
value = apdu.propertyValue.cast_out(datatype)
if hasattr(value, "dict_contents"):
value = value.dict_contents(as_class=OrderedDict)
if _debug:
HTTPRequestHandler._debug(" - value: %r", value)
result = {"value": value}
except Exception as err:
HTTPRequestHandler._exception("exception: %r", err)
result = {"exception": str(err)}
self.send_header('Content-Type', 'application/json')
self.end_headers()
result_bytes = json.dumps(result).encode("utf-8")
self.wfile.write(result_bytes)
return
# encode the results as JSON, convert to bytes
result_bytes = json.dumps(result).encode("utf-8")
# write the result
self.send_header('Content-Type', 'application/json')
self.end_headers()
self.wfile.write(result_bytes)
return