def __init__(self, *args):
BIPSimpleApplication.__init__(Mock())
self.elementService = Mock()
self.ResponseQueue = Mock()
self.ResponseQueue.get.return_value = (None, Event())
self.request = Mock()
self.value = None
def indication(self, apdu):
"""Given an I-Am request, cache it.
Indication will treat unconfirmed messages on the stack
:param apdu: apdu
"""
if _debug: ScriptApplication._debug("do_IAmRequest %r", apdu)
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
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
BIPSimpleApplication.do_WhoIsRequest(self, apdu)
# pass back to the default implementation
BIPSimpleApplication.indication(self, apdu)
def Init(pAddress):
global this_application, this_ServerAdress
this_ServerAdress = pAddress
# 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
def __init__(self, *args):
BIPSimpleApplication.__init__(Mock())
self.elementService = Mock()
#self.ResponseQueue = Mock()
#self.ResponseQueue.get.return_value = ([21, 'degreesCelcius'], Event())
iocb = IOCB()
apdu = ReadPropertyMultipleACK(listOfReadAccessResults=[
ReadAccessResult(
objectIdentifier=('analogValue', 1),
listOfResults=[
ReadAccessResultElement(
propertyIdentifier='presentValue',
readResult=ReadAccessResultElementChoice(
propertyValue=Any(Real(21.0)), )),
ReadAccessResultElement(
propertyIdentifier='units',
readResult=ReadAccessResultElementChoice(
propertyValue=Any(Enumerated(62)), )),
],
)
])
iocb.complete(apdu)
self.request = Mock()
self.request.return_value = iocb
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('\n')
sys.stdout.write('Device Address = ' + repr(apdu.pduSource) + '\n')
sys.stdout.write('Device Id = ' + str(device_instance) + '\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()
if this_csv_file is not None:
row = {"address":apdu.pduSource,
"device_id": device_instance,
"max_apdu_length": apdu.maxAPDULengthAccepted,
"segmentation_supported": apdu.segmentationSupported,
"vendor_id": apdu.vendorID}
this_csv_file.writerow(row)
# forward it along
BIPSimpleApplication.indication(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('\n')
sys.stdout.write('Device Address = ' + 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)
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)
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 __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 __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 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:
# Received I-am from target's Device instance
dev_ObjID = apdu.iAmDeviceIdentifier
dev_pdusource = apdu.pduSource
point_list[0][0] = str(dev_pdusource)
point_list[1][0] = str(dev_pdusource)
point_list[0][2] = dev_ObjID[1]
point_list[1][2] = dev_ObjID[1]
#fire off request. read device properties model name and software version
deferred(self.next_request)
# forward it along
BIPSimpleApplication.indication(self, apdu)
def next_request(self):
if _debug: PrairieDog._debug("next_request")
# check to see if we're done
if not self.point_queue:
if _debug: PrairieDog._debug(" - done")
# dump out the results
for request, response in zip(point_list, self.response_values):
print request, response
# no longer busy
self.is_busy = False
return
# get the next request
addr, obj_type, obj_inst, prop_id = self.point_queue.popleft()
# build a request
self._request = ReadPropertyRequest(
objectIdentifier=(obj_type, obj_inst),
propertyIdentifier=prop_id,
)
self._request.pduDestination = Address(addr)
if _debug: PrairieDog._debug(" - request: %r", self._request)
# forward it along
BIPSimpleApplication.request(self, self._request)
def __init__(self, *args):
if _debug:
ReadRangeApplication._debug("__init__ %r", args)
BIPSimpleApplication.__init__(self, *args)
# keep track of requests to line up responses
self._request = None
def __init__(self, *args):
BIPSimpleApplication.__init__(Mock())
self.elementService = Mock()
self.ResponseQueue = Mock()
self.ResponseQueue.get.return_value = ([21, 'degreesCelcius'], Event())
self.request = Mock()
self.value = None
def __init__(self, point_list, *args):
if _debug:
ReadPointListApplication._debug("__init__ %r, %r", point_list, args)
BIPSimpleApplication.__init__(self, *args)
# turn the point list into a queue
self.point_queue = deque(point_list)
def indication(self, apdu): # # IAmRequest の 解析 # if isinstance(apdu, IAmRequest): # # デバイスID, IPアドレスの取得 # ipaddr = apdu.pduSource device_type, device_instance = apdu.iAmDeviceIdentifier # # デバイスID と IPアドレスのマッピング管理 # self.device_map[device_instance] = ipaddr # # IAmRequest を 取得したことを通知する # self.responseQueue.put(device_instance) # # forward it along # BIPSimpleApplication.indication(self, apdu)
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 __init__(self, *args):
"""
Creation of the application. Adding properties to basic B/IP App.
:param *args: local object device, local IP address
See BAC0.scripts.BasicScript for more details.
"""
logging.getLogger("comtypes").setLevel(logging.INFO)
log_debug("__init__ %r", args)
self.localAddress = None
BIPSimpleApplication.__init__(self, *args)
# _lock will be used by read/write operation to wait for answer before
# making another request
self._lock = Lock()
self._request = None
self.value = None
self.error = None
self.values = []
self.i_am_counter = defaultdict(int)
self.who_is_counter = defaultdict(int)
self.ResponseQueue = Queue()
if isinstance(self.localAddress, Address):
self.local_unicast_tuple = self.localAddress.addrTuple
self.local_broadcast_tuple = self.localAddress.addrBroadcastTuple
else:
self.local_unicast_tuple = ('', 47808)
self.local_broadcast_tuple = ('255.255.255.255', 47808)
def indication(self, apdu):
"""Given an I-Am request, cache it.
Indication will treat unconfirmed messages on the stack
:param apdu: apdu
"""
if _debug: ScriptApplication._debug("do_IAmRequest %r", apdu)
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
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
BIPSimpleApplication.do_WhoIsRequest(self, apdu)
# pass back to the default implementation
BIPSimpleApplication.indication(self, apdu)
def __init__(self, *args):
"""
Creation of the application. Adding properties to basic B/IP App.
:param *args: local object device, local IP address
See BAC0.scripts.BasicScript for more details.
"""
logging.getLogger("comtypes").setLevel(logging.INFO)
log_debug("__init__ %r", args)
self.localAddress = None
BIPSimpleApplication.__init__(self, *args)
# _lock will be used by read/write operation to wait for answer before
# making another request
self._lock = Lock()
self._request = None
self.value = None
self.error = None
self.values = []
self.i_am_counter = defaultdict(int)
self.who_is_counter = defaultdict(int)
self.ResponseQueue = Queue()
if isinstance(self.localAddress, Address):
self.local_unicast_tuple = self.localAddress.addrTuple
self.local_broadcast_tuple = self.localAddress.addrBroadcastTuple
else:
self.local_unicast_tuple = ('', 47808)
self.local_broadcast_tuple = ('255.255.255.255', 47808)
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 __init__(self,*args,**kwarg):
self.userdata=None
device=LocalDeviceObject(vendorIdentifier=47808,objectIdentifier=47808)
print('BacnetAppInit',*args,**kwarg)
BIPSimpleApplication.__init__(self,device,*args,**kwarg)
#time.sleep(0.8)#等待bac run
self.whoisback=None
self.who_is({})
def request(self, apdu):
if _debug: SubscribeCOVApplication._debug("request %r", apdu)
# save a copy of the request
self._request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
def request(self, apdu):
"""Sniff for Who-Is requests going downstream."""
# save a copy of just the Who-Is request
if isinstance(apdu, WhoIsRequest):
self.who_is_request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
def process_io(self, iocb):
if _debug: WhoIsIAmApplication._debug("process_io %r", iocb)
# save a copy of the request
self._request = iocb.args[0]
# forward it along
BIPSimpleApplication.process_io(self, iocb)
def request(self, apdu):
if _debug: BACnetAggregator._debug("request %r", apdu)
# save a copy of the request
self._request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
def request(self, apdu):
if _debug: ReadPropertyApplication._debug("request %r", apdu)
# save a copy of the request
self._request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
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 __init__(self, hmi, *args):
self._debug = True
self._hmi = hmi
if self._debug: print("__init__ %r", args)
BIPSimpleApplication.__init__(self, *args)
if self._debug: print("super called")
# keep track of requests to line up responses
self._request = None
def __init__(self, *args):
BIPSimpleApplication.__init__(self, *args)
# assigning invoke identifiers
self.nextInvokeID = 1
# keep track of requests to line up responses
self.iocb = {}
def __init__(self, *args):
BIPSimpleApplication.__init__(self, *args)
# assigning invoke identifiers
self.nextInvokeID = 1
# keep track of requests to line up responses
self.iocb = {}
def who_is(self,config):
function.log('whoIs',config)
self.userdata=[]
BIPSimpleApplication.who_is(self,
low_limit=config['lowlimits'],
high_limit=config['highlimits']
)
return self.userdata
def request(self, apdu):
# if _debug: ReadPropertyApplication._debug("request %r", apdu)
# save a copy of the request
self._request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
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 request(self, apdu):
if self._debug: print("request %r", apdu)
# save a copy of the request
self._request = apdu
# forward it along
BIPSimpleApplication.request(self, apdu)
if self._debug: print "ok"
def __init__(self, point_list, *args):
if _debug: ReadPointListApplication._debug("__init__ %r, %r", point_list, args)
BIPSimpleApplication.__init__(self, *args)
# turn the point list into a queue
self.point_queue = deque(point_list)
# make a list of the response values
self.response_values = []
def __init__(self, *args):
if _debug: WebServerApplication._debug("__init__ %r", args)
BIPSimpleApplication.__init__(self, *args)
# assigning invoke identifiers
self.nextInvokeID = 1
# keep track of requests to line up responses
self.iocb = {}
def do_request(self, apdu, iocb):
# assign an invoke identifier
apdu.apduInvokeID = self.get_next_invoke_id(apdu.pduDestination)
# build a key to reference the IOCB when the response comes back
invoke_key = (apdu.pduDestination, apdu.apduInvokeID)
# keep track of the request
self.iocb[invoke_key] = iocb
# forward it along, apduInvokeID set by stack
BIPSimpleApplication.request(self, apdu)
def response(self, apdu):
if _debug: TestApplication._debug("response %r", apdu)
# check for loopback
if apdu.pduDestination == self.localAddress:
if _debug: TestApplication._debug(" - loopback")
deferred(self.confirmation, apdu)
else:
BIPSimpleApplication.response(self, apdu)
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 do_IAmRequest(self, apdu):
"""Given an I-Am request, cache it."""
self.log(("do_IAmRequest {!r}".format(apdu)))
# build a key from the source, just use the instance number
key = (str(apdu.pduSource), apdu.iAmDeviceIdentifier[1])
self.i_am_counter[key] += 1
# continue with the default implementation
BIPSimpleApplication.do_IAmRequest(self, apdu)
def who_is(self,config,back=None):
#self.i_am()
print('whoIs',config)
self.userdata=[]
self.whoisback=back
BIPSimpleApplication.who_is(self,
low_limit=config.get('lowlimits',0),
high_limit=config.get('highlimits',10000)
)
return self.userdata
def __init__(self, interval, *args):
if _debug: PrairieDog._debug("__init__ %r %r", interval, args)
BIPSimpleApplication.__init__(self, *args)
RecurringTask.__init__(self, interval * 1000)
# no longer busy
self.is_busy = False
# install the task
self.install_task()
def __init__(self, point_list, *args):
if _debug: ReadPointListApplication._debug("__init__ %r, %r", point_list, args)
BIPSimpleApplication.__init__(self, *args)
# keep track of requests to line up responses
self._request = None
# make a list of the response values
self.response_values = []
# turn the point list into a queue
self.point_queue = deque(point_list)
def main():
if _debug: main._debug("initialization")
try:
# parse the command line arguments
args = ConfigArgumentParser(description=__doc__).parse_args()
if _debug: main._debug("initialization")
if _debug: main._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=vendor_id,
)
# 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 objects
ravo1 = VendorAVObject(
objectIdentifier=(513, 1), objectName='Random1'
)
if _debug: main._debug(" - ravo1: %r", ravo1)
ravo2 = VendorAVObject(
objectIdentifier=(513, 2), objectName='Random2'
)
if _debug: main._debug(" - ravo2: %r", ravo2)
# add it to the device
this_application.add_object(ravo1)
this_application.add_object(ravo2)
if _debug: main._debug(" - object list: %r", this_device.objectList)
if _debug: main._debug("running")
run()
except Exception as error:
main._exception("an error has occurred: %s", error)
finally:
if _debug: main._debug("finally")
def __init__(self, *args):
BIPSimpleApplication.__init__(self, *args)
RecurringTask.__init__(self, 250)
self.request_queue = Queue()
# assigning invoke identifiers
self.nextInvokeID = 1
# keep track of requests to line up responses
self.iocb = {}
self.install_task()
def indication(self, apdu):
if isinstance(apdu, IAmRequest):
device_type, device_instance = apdu.iAmDeviceIdentifier
if device_type != 'device':
# Bail without an error.
return
_log.debug("Calling IAm callback.")
self.i_am_callback(str(apdu.pduSource),
device_instance,
apdu.maxAPDULengthAccepted,
str(apdu.segmentationSupported),
apdu.vendorID)
elif isinstance(apdu, ConfirmedCOVNotificationRequest):
# Handling for ConfirmedCOVNotificationRequests. These requests are
# sent by the device when a point with a COV subscription updates
# past the covIncrement threshold(See COV_Detection class in
# Bacpypes:
# https://bacpypes.readthedocs.io/en/latest/modules/service/cov.html)
_log.debug("ConfirmedCOVNotificationRequest received from {}"
.format(apdu.pduSource))
point_name = None
device_path = None
result_dict = {}
for element in apdu.listOfValues:
property_id = element.propertyIdentifier
if not property_id == "statusFlags":
values = []
for tag in element.value.tagList:
values.append(tag.app_to_object().value)
if len(values) == 1:
result_dict[property_id] = values[0]
else:
result_dict[property_id] = values
if result_dict:
context = \
self.sub_cov_contexts[apdu.subscriberProcessIdentifier]
point_name = context.point_name
device_path = context.device_path
if point_name and device_path:
self.forward_cov_callback(device_path, point_name, result_dict)
else:
_log.debug("Device {} does not have a subscription context."
.format(apdu.monitoredObjectIdentifier))
# forward it along
BIPSimpleApplication.indication(self, apdu)
def do_IAmRequest(self, apdu):
"""Given an I-Am request, cache it."""
if _debug:
WhoIsIAmApplication._debug("do_IAmRequest %r", apdu)
# 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
i_am_counter[key] += 1
# continue with the default implementation
BIPSimpleApplication.do_IAmRequest(self, apdu)
def do_WhoIsRequest(self, apdu):
"""Respond to a Who-Is request."""
if _debug:
WhoIsIAmApplication._debug("do_WhoIsRequest %r", apdu)
# build a key from the source and parameters
key = (str(apdu.pduSource), apdu.deviceInstanceRangeLowLimit, apdu.deviceInstanceRangeHighLimit)
# count the times this has been received
who_is_counter[key] += 1
# continue with the default implementation
BIPSimpleApplication.do_WhoIsRequest(self, apdu)
def request(self, iocb):
apdu = iocb.ioRequest
# assign an invoke identifier
apdu.apduInvokeID = self.get_next_invoke_id(apdu.pduDestination)
# build a key to reference the IOCB when the response comes back
invoke_key = (apdu.pduDestination, apdu.apduInvokeID)
# keep track of the request
self.iocb[invoke_key] = iocb
BIPSimpleApplication.request(self, apdu)
def __init__(self, interval, *args):
if _debug: PrairieDog._debug("__init__ %r, %r", interval, args)
BIPSimpleApplication.__init__(self, *args)
RecurringTask.__init__(self, interval * 1000)
# keep track of requests to line up responses
self._request = None
# start out idle
self.is_busy = False
self.point_queue = deque()
self.response_values = []
# install it
self.install_task()
def do_WhoIsRequest(self, apdu):
"""Respond to a Who-Is request."""
self.log(("do_WhoIsRequest {!r}".format(apdu)))
# 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
# continue with the default implementation
BIPSimpleApplication.do_WhoIsRequest(self, apdu)
def indication(self, apdu):
if isinstance(apdu, IAmRequest):
device_type, device_instance = apdu.iAmDeviceIdentifier
if device_type != 'device':
#Bail without an error.
return
_log.debug("Calling IAm callback.")
self.i_am_callback(str(apdu.pduSource),
device_instance,
apdu.maxAPDULengthAccepted,
str(apdu.segmentationSupported),
apdu.vendorID)
# forward it along
BIPSimpleApplication.indication(self, apdu)
def __init__(self, *args):
"""Creation of the application. Adding properties to basic B/IP App.
:param *args: local object device, local IP address
See BAC0.scripts.BasicScript for more details.
"""
if _debug: ScriptApplication._debug("__init__ %r", args)
BIPSimpleApplication.__init__(self, *args)
# keep track of requests to line up responses
self._request = None
self.value = None
self.error = None
self.values = []
self.i_am_counter = defaultdict(int)
self.ResponseQueue = Queue()
def request(self, iocb):
apdu = iocb.ioRequest
if isinstance(apdu, ConfirmedRequestSequence):
# assign an invoke identifier
apdu.apduInvokeID = self.get_next_invoke_id(apdu.pduDestination)
# build a key to reference the IOCB when the response comes back
invoke_key = (apdu.pduDestination, apdu.apduInvokeID)
# keep track of the request
self.iocb[invoke_key] = iocb
try:
BIPSimpleApplication.request(self, apdu)
except StandardError as e:
iocb.set_exception(e)
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(
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 = 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():
# 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 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 a multistate value object
msvo = MultiStateValueObject(
objectIdentifier=('multiStateValue', 1),
objectName='My Special Object',
presentValue=1,
numberOfStates=3,
stateText=ArrayOf(CharacterString)(['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 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),
)
# make a sample application
this_application = BIPSimpleApplication(this_device, args.ini.address)
# make a commandable analog value object, add to the device
cavo1 = CommandableAnalogValueObject(objectIdentifier=("analogValue", 1), objectName="Commandable1")
if _debug:
_log.debug(" - cavo1: %r", cavo1)
this_application.add_object(cavo1)
# get the current date
today = Date().now()
# make a commandable date value object, add to the device
cdvo2 = CommandableDateValueObject(
objectIdentifier=("dateValue", 1), objectName="Commandable2", presentValue=today.value
)
if _debug:
_log.debug(" - cdvo2: %r", cdvo2)
this_application.add_object(cdvo2)
if _debug:
_log.debug("running")
run()
_log.debug("fini")
