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