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 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 run_application(objectidentifier: int):
global this_device
global this_application
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an argument for interval
parser.add_argument(
'device_id',
type=int,
help='device identifier',
)
# add an argument for interval
parser.add_argument(
'device_addr',
type=str,
help='device address',
)
# make a device object
this_device = LocalDeviceObject(
objectName="objectpropertyreader",
objectIdentifier=599,
maxApduLengthAccepted=1024,
segmentationSupported="segmentedBoth",
vendorIdentifier=15,
)
import netifaces
from ipaddress import IPv4Network
wifi_ip = netifaces.ifaddresses('en0')[netifaces.AF_INET][0]
#Addres of this device which will perform the querying.
address = wifi_ip['addr'] + "/" + str(
IPv4Network("0.0.0.0/" + wifi_ip['netmask']).prefixlen) + ":47809"
# make a simple application
this_application = ReadAllObjectPropertiesApplication(this_device, address)
# build a device object identifier
device_id = ('device', objectidentifier)
# Address of device being queried.
device_addr = Address(
wifi_ip['addr'] + "/" +
str(IPv4Network("0.0.0.0/" + wifi_ip['netmask']).prefixlen) + ":47808")
# kick off the process after the core is up and running
deferred(this_application.read_object_list, device_id, device_addr)
_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 args, this_application
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an argument for seconds per dog
parser.add_argument("daddr", help="destination address")
parser.add_argument("objid", help="object identifier")
parser.add_argument("propid", help="property identifier")
# list of values to write
parser.add_argument("values",
metavar="N",
nargs="+",
help="values to write")
# add an argument for seconds between writes
parser.add_argument("--delay",
type=float,
help="delay between writes in seconds",
default=5.0)
# now parse the arguments
args = parser.parse_args()
# convert the parameters
args.daddr = Address(args.daddr)
args.objid = ObjectIdentifier(args.objid).value
args.propid = PropertyIdentifier(args.propid).value
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 dog, task scheduling is in milliseconds
dog = PrairieDog(args.delay * 1000)
if _debug:
_log.debug(" - dog: %r", dog)
_log.debug("running")
run()
_log.debug("fini")
def main():
global this_device
global this_application
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an argument for interval
parser.add_argument(
'device_id',
type=int,
help='device identifier',
)
# add an argument for interval
parser.add_argument(
'device_addr',
type=str,
help='device address',
)
# parse the args
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 = ReadObjectListApplication(this_device, args.ini.address)
# build a device object identifier
device_id = ('device', args.device_id)
# translate the address
device_addr = Address(args.device_addr)
# kick off the process after the core is up and running
deferred(this_application.read_object_list, device_id, device_addr)
_log.debug("running")
run()
_log.debug("fini")
def setUp(self):
global server, server_thread, this_application
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an option for the server host
parser.add_argument("--host",
type=str,
help="server host",
default=HOST)
# add an option for the server port
parser.add_argument("--port",
type=int,
help="server port",
default=PORT)
# Adding arguments to the argument parser
config_path = "./bacnet_client.ini"
args = parser.parse_args(['--ini', config_path])
# Make a HTTP Server
server = ThreadedTCPServer((args.host, args.port), HTTPRequestHandler)
# Start a thread with the server -- that thread will then start a thread for each request
server_thread = threading.Thread(target=server.serve_forever)
# exit the server thread when the main thread terminates
server_thread.daemon = True # Exit when program terminates
server_thread.start()
print("HTTP Server Thread is Alive : ", server_thread.is_alive())
# Make a device object
this_device = LocalDeviceObject(ini=args.ini)
# Make a simple application
this_application = BIPSimpleApplication(this_device, args.ini.address)
BACnetHTTPServer.this_application = this_application
# Start the BACnet application in a child thread
# Child threads do not receive signals SIGTERM or SIGUSR1
bac_thread = threading.Thread(target=run)
bac_thread.daemon = True # Exit when program terminates
bac_thread.start()
print("BACnet client Thread is Alive : ", bac_thread.is_alive())
return
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(
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 = ReadPointListApplication(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
_log.debug("running")
run()
_log.debug("fini")
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(
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 dog
this_application = PrairieDog(args.interval, this_device, args.ini.address)
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
_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(
"objid",
help="object identifier",
)
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.objid
if _debug: _log.debug(" - context: %r", context)
# 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 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_application, device_address, object_identifier, property_list
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"address",
help="device address",
)
parser.add_argument(
"objtype",
help="object types, e.g., analogInput",
)
parser.add_argument(
"objinstance",
type=int,
help="object instance",
)
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# interpret the address
device_address = Address(args.address)
if _debug: _log.debug(" - device_address: %r", device_address)
# build an identifier
object_identifier = (args.objtype, args.objinstance)
if _debug: _log.debug(" - object_identifier: %r", object_identifier)
# get the object class
object_class = get_object_class(args.objtype)
if _debug: _log.debug(" - object_class: %r", object_class)
# make a queue of the properties
property_list = deque(prop.identifier for prop in object_class.properties)
if _debug: _log.debug(" - property_list: %r", property_list)
# 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 = ReadPropertyApplication(this_device, args.ini.address)
# fire off a request when the core has a chance
deferred(this_application.next_request)
_log.debug("running")
run()
_log.debug("fini")
def main():
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("device_id",
type=int,
help="Device ID of the target device")
arg_parser.add_argument(
"--address",
help=
"Address of target device, may be needed to help route initial request to device."
)
arg_parser.add_argument("--out-file",
type=argparse.FileType('wb'),
help="Optional output file for configuration",
default=sys.stdout)
arg_parser.add_argument(
"--max_range_report",
nargs='?',
type=float,
help=
'Affects how very large numbers are reported in the "Unit Details" column of the output. '
'Does not affect driver behavior.',
default=1.0e+20)
args = arg_parser.parse_args()
_log.debug("initialization")
_log.debug(" - args: %r", args)
ips = getIPs()
print "found local ip as ", ips
device_address = ips[0] + "/24"
# make a device object
this_device = LocalDeviceObject(
objectName="BEMOSS",
objectIdentifier=int(599),
maxApduLengthAccepted=int(1024),
segmentationSupported=args.ini.segmentationsupported,
vendorIdentifier=int(args.ini.vendoridentifier),
)
# make a simple application
this_application = SynchronousApplication(this_device, device_address)
_log.debug("starting build")
result = get_iam(this_application, args.device_id, args.address)
target_address = result.pduSource
_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))
device_id = result.iAmDeviceIdentifier[1]
try:
device_name = read_prop(this_application, target_address, "device",
device_id, "objectName")
_log.debug('device_name = ' + str(device_name))
except TypeError:
_log.debug('device missing objectName')
try:
device_description = read_prop(this_application, target_address,
"device", device_id, "description")
_log.debug('description = ' + str(device_description))
except TypeError:
_log.debug('device missing description')
config_writer = DictWriter(
args.out_file, ('Reference Point Name', 'Volttron Point Name', 'Units',
'Unit Details', 'BACnet Object Type', 'Property',
'Writable', 'Index', 'Write Priority', 'Notes'))
config_writer.writeheader()
try:
objectCount = read_prop(this_application,
target_address,
"device",
device_id,
"objectList",
index=0)
list_property = "objectList"
except TypeError:
objectCount = read_prop(this_application,
target_address,
"device",
device_id,
"structuredObjectList",
index=0)
list_property = "structuredObjectList"
_log.debug('objectCount = ' + str(objectCount))
for object_index in xrange(1, objectCount + 1):
_log.debug('object_device_index = ' + repr(object_index))
bac_object = read_prop(this_application,
target_address,
"device",
device_id,
list_property,
index=object_index)
obj_type, index = bac_object
print object_index
print
print
process_object(this_application, target_address, obj_type, index,
args.max_range_report, config_writer)
def main():
global args, this_device, this_application
# build a parser, add some options
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
'--lan',
type=str,
default=bacpypes_mqtt.default_lan_name,
help='lan name',
)
parser.add_argument(
'--host',
type=str,
default=bacpypes_mqtt.default_broker_host,
help='broker host address',
)
parser.add_argument(
'--port',
type=int,
default=bacpypes_mqtt.default_broker_port,
help='broker port',
)
parser.add_argument(
'--keepalive',
type=int,
default=bacpypes_mqtt.default_broker_keepalive,
help=
"maximum period in seconds allowed between communications with the broker",
)
# 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 = MQTTApplication(this_device, args.lan, args.ini.address)
# make a console
this_console = ClientConsoleCmd()
if _debug: _log.debug(" - this_console: %r", this_console)
# enable sleeping will help with threads
enable_sleeping()
# start up the client
this_application.mse.startup()
_log.debug("running")
run()
# shutdown the client
this_application.mse.shutdown()
_log.debug("fini")
result = this_application.make_request(request)
if not isinstance(result, ReadPropertyACK):
result.debug_contents(file=sys.stderr)
raise TypeError, "Error reading property"
# find the datatype
datatype = get_datatype(obj_type, prop_id)
return result.propertyValue.cast_out(datatype)
try:
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("address", help="Address of target device")
arg_parser.add_argument("out_file",
nargs='?',
type=argparse.FileType('wb'),
help="Optional output file for configuration",
default=sys.stdout)
arg_parser.add_argument(
"--max_range_report",
nargs='?',
type=float,
help=
'Affects how very large numbers are reported in the "Unit Details" column of the output. '
'Does not affect sMap driver behavior.',
default=1.0e+20)
def main():
global args, this_device, this_application, snapshot
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# input file for exiting configuration
parser.add_argument(
"infile",
default="-",
help="input file",
)
# output file for discovered configuration
parser.add_argument(
"outfile",
nargs='?',
default='-unspecified-',
help="output file",
)
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 = DiscoverApplication(
this_device,
args.ini.address,
)
if _debug: _log.debug(" - this_application: %r", this_application)
# make a snapshot 'database'
snapshot = Snapshot()
# read in an existing snapshot
if args.infile != '-':
snapshot.read_file(args.infile)
# make a console
this_console = DiscoverConsoleCmd()
_log.debug(" - this_console: %r", this_console)
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
# write out the snapshot, outfile defaults to infile if not specified
if args.outfile == '-unspecified-':
args.outfile = args.infile
if args.outfile != '-':
snapshot.write_file(args.outfile)
sys.stdout.write("%d woof!\n" % (self.dog_number, ))
#
# __main__
#
try:
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an argument for seconds per dog
parser.add_argument(
'seconds',
metavar='N',
type=int,
nargs='+',
help='number of seconds for each dog',
)
# now parse the arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make some dogs
for i, sec in enumerate(args.seconds):
dog = PrairieDog(i, sec * 1000)
if _debug: _log.debug(" - dog: %r", dog)
class ThreadedTCPServer(ThreadingMixIn, TCPServer):
pass
#
# __main__
#
try:
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an option for the server host
parser.add_argument("--host", type=str, help="server host", default=HOST)
# add an option for the server port
parser.add_argument("--port", type=int, help="server port", default=PORT)
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
def main():
global test_application
# make a parser
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"--console",
action="store_true",
default=False,
help="create a console",
)
# 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
test_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
test_application = SubscribeCOVApplication(test_device, args.ini.address)
# make a binary value object
test_bv = BinaryValueObject(
objectIdentifier=('binaryValue', 1),
objectName='bv',
presentValue='inactive',
statusFlags=[0, 0, 0, 0],
)
_log.debug(" - test_bv: %r", test_bv)
# add it to the device
test_application.add_object(test_bv)
# make an analog value object
test_av = AnalogValueObject(
objectIdentifier=('analogValue', 1),
objectName='av',
presentValue=0.0,
statusFlags=[0, 0, 0, 0],
covIncrement=1.0,
)
_log.debug(" - test_av: %r", test_av)
# add it to the device
test_application.add_object(test_av)
_log.debug(" - object list: %r", test_device.objectList)
# get the services supported
services_supported = test_application.get_services_supported()
if _debug: _log.debug(" - services_supported: %r", services_supported)
# let the device object know
test_device.protocolServicesSupported = services_supported.value
# make a console
if args.console:
test_console = COVConsoleCmd()
_log.debug(" - test_console: %r", test_console)
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
pass
#
# __main__
#
try:
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an option to override the port in the config file
parser.add_argument(
'--port',
help="override the port in the config file to PORT",
default="9000",
)
args = parser.parse_args()
if _debug: _log.debug("initialization")
# 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),
)
def main():
global args, this_device, this_application
# parse the command line arguments
parser = ConfigArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
# add an argument for interval
parser.add_argument('net1', type=int,
help='network number of IPv4 network',
)
# add an argument for interval
parser.add_argument('net2', type=int,
help='network number of VLAN network',
)
# add an argument for interval
parser.add_argument('addr2', type=str,
help='address on the VLAN network',
)
# now parse the arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
local_network = args.net1
local_address = Address(args.ini.address)
if _debug: _log.debug(" - local_network, local_address: %r, %r", local_network, local_address)
vlan_network = args.net2
vlan_address = Address(args.addr2)
if _debug: _log.debug(" - vlan_network, vlan_address: %r, %r", vlan_network, vlan_address)
# create the VLAN router, bind it to the local network
router = VLANRouter(local_address, local_network)
# create a VLAN
vlan = Network(broadcast_address=LocalBroadcast())
# create a node for the router, address 1 on the VLAN
router_node = Node(Address(1))
vlan.add_node(router_node)
# bind the router stack to the vlan network through this node
router.nsap.bind(router_node, vlan_network)
# send network topology
deferred(router.nse.i_am_router_to_network)
# make a vlan device object
this_device = \
LocalDeviceObject(
objectName=args.ini.objectname,
objectIdentifier=("device", int(args.ini.objectidentifier)),
maxApduLengthAccepted=1024,
segmentationSupported='noSegmentation',
vendorIdentifier=15,
)
_log.debug(" - this_device: %r", this_device)
# make the application, add it to the network
this_application = VLANApplication(this_device, vlan_address)
vlan.add_node(this_application.vlan_node)
_log.debug(" - this_application: %r", this_application)
# make a console
this_console = WhoIsIAmConsoleCmd()
if _debug: _log.debug(" - this_console: %r", this_console)
_log.debug("running")
run()
_log.debug("fini")
# give it to the application
this_application.request(request)
except Exception, e:
WhoIsIAmConsoleCmd._exception("exception: %r", e)
#
# __main__
#
try:
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("--address",
help="Target only device(s) at <address> for request" )
arg_parser.add_argument("--range", type=int, nargs=2, metavar=('LOW', 'HIGH'),
help="Lower and upper limit on device ID in results" )
arg_parser.add_argument("--timeout", type=int, metavar=('SECONDS'),
help="Time, in seconds, to wait for responses. Default: %(default)s",
default = 5)
args = arg_parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make a device object
this_device = LocalDeviceObject(
def main():
global test_application
# make a parser
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument("--console",
action="store_true",
default=False,
help="create a console",
)
# 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
test_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
test_application = SubscribeCOVApplication(test_device, args.ini.address)
# make a binary value object
test_bv = BinaryValueObject(
objectIdentifier=('binaryValue', 1),
objectName='bv',
presentValue='inactive',
statusFlags=[0, 0, 0, 0],
)
_log.debug(" - test_bv: %r", test_bv)
# add it to the device
test_application.add_object(test_bv)
# make an analog value object
test_av = AnalogValueObject(
objectIdentifier=('analogValue', 1),
objectName='av',
presentValue=0.0,
statusFlags=[0, 0, 0, 0],
covIncrement=1.0,
)
_log.debug(" - test_av: %r", test_av)
# add it to the device
test_application.add_object(test_av)
_log.debug(" - object list: %r", test_device.objectList)
# get the services supported
services_supported = test_application.get_services_supported()
if _debug: _log.debug(" - services_supported: %r", services_supported)
# let the device object know
test_device.protocolServicesSupported = services_supported.value
# make a console
if args.console:
test_console = COVConsoleCmd()
_log.debug(" - test_console: %r", test_console)
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
def main():
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("device_id", type=int,
help="Device ID of the target device" )
arg_parser.add_argument("--address",
help="Address of target device, may be needed to help route initial request to device." )
arg_parser.add_argument("--registry-out-file", type=argparse.FileType('wb'),
help="Output registry to CSV file",
default=sys.stdout )
arg_parser.add_argument("--driver-out-file", type=argparse.FileType('wb'),
help="Output driver configuration to JSON file.",
default=sys.stdout)
arg_parser.add_argument("--max-range-report", nargs='?', type=float,
help='Affects how very large numbers are reported in the "Unit Details" column of the output. '
'Does not affect driver behavior.',
default=1.0e+20 )
args = arg_parser.parse_args()
_log.debug("initialization")
_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 = SynchronousApplication(this_device, args.ini.address)
_log.debug("starting build")
result = get_iam(this_application, args.device_id, args.address)
# request = WhoIsRequest()
# request.pduDestination = target_address
# result = this_application.make_request(request, expect_confirmation = False)
# if not isinstance(result, IAmRequest):
# result.debug_contents()
# raise TypeError("Error making WhoIs request, try running again.")
# device_type, device_instance = result.iAmDeviceIdentifier
# if device_type != 'device':
# raise DecodingError("invalid object type")
target_address = result.pduSource
device_id = result.iAmDeviceIdentifier[1]
_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))
config_file_name = basename(args.registry_out_file.name)
config = {
"driver_config":{"device_address":str(target_address),
"device_id": device_id},
"driver_type":"bacnet",
"registry_config":"config://registry_configs/{}".format(config_file_name)
}
json.dump(config, args.driver_out_file,indent=4)
try:
device_name = read_prop(this_application, target_address, "device", device_id, "objectName")
_log.debug('device_name = ' + str(device_name))
except TypeError:
_log.debug('device missing objectName')
try:
device_description = read_prop(this_application, target_address, "device", device_id, "description")
_log.debug('description = ' + str(device_description))
except TypeError:
_log.debug('device missing description')
config_writer = DictWriter(args.registry_out_file,
('Reference Point Name',
'Volttron Point Name',
'Units',
'Unit Details',
'BACnet Object Type',
'Property',
'Writable',
'Index',
'Write Priority',
'Notes'))
config_writer.writeheader()
try:
objectCount = read_prop(this_application, target_address, "device", device_id, "objectList", index=0)
list_property = "objectList"
except TypeError:
objectCount = read_prop(this_application, target_address, "device", device_id, "structuredObjectList", index=0)
list_property = "structuredObjectList"
_log.debug('objectCount = ' + str(objectCount))
for object_index in xrange(1,objectCount+1):
_log.debug('object_device_index = ' + repr(object_index))
bac_object = read_prop(this_application,
target_address,
"device",
device_id,
list_property,
index=object_index)
obj_type, index = bac_object
try:
process_object(this_application, target_address, obj_type, index, args.max_range_report, config_writer)
except:
_log.debug("Unexpected error processing object: {} {}".format(obj_type, index))
_log.debug(traceback.format_exc())
def main():
global test_av, test_bv, test_application
# make a parser
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"--console",
action="store_true",
default=False,
help="create a console",
)
# analog value task and thread
parser.add_argument(
"--avtask",
type=float,
help="analog value recurring task",
)
parser.add_argument(
"--avthread",
type=float,
help="analog value thread",
)
# analog value task and thread
parser.add_argument(
"--bvtask",
type=float,
help="binary value recurring task",
)
parser.add_argument(
"--bvthread",
type=float,
help="binary value thread",
)
# provide a different spin value
parser.add_argument(
"--spin",
type=float,
help="spin time",
default=1.0,
)
# 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 sample application
test_application = SubscribeCOVApplication(this_device, args.ini.address)
# make an analog value object
test_av = WritableAnalogValueObject(
objectIdentifier=("analogValue", 1),
objectName="av",
presentValue=0.0,
statusFlags=[0, 0, 0, 0],
covIncrement=1.0,
)
_log.debug(" - test_av: %r", test_av)
# add it to the device
test_application.add_object(test_av)
_log.debug(" - object list: %r", this_device.objectList)
# make a binary value object
test_bv = BinaryValueObject(
objectIdentifier=("binaryValue", 1),
objectName="bv",
presentValue="inactive",
statusFlags=[0, 0, 0, 0],
)
_log.debug(" - test_bv: %r", test_bv)
# add it to the device
test_application.add_object(test_bv)
# make a console
if args.console:
test_console = COVConsoleCmd()
_log.debug(" - test_console: %r", test_console)
# enable sleeping will help with threads
enable_sleeping()
# analog value task
if args.avtask:
test_av_task = TestAnalogValueTask(args.avtask)
test_av_task.install_task()
# analog value thread
if args.avthread:
test_av_thread = TestAnalogValueThread(args.avthread)
deferred(test_av_thread.start)
# binary value task
if args.bvtask:
test_bv_task = TestBinaryValueTask(args.bvtask)
test_bv_task.install_task()
# binary value thread
if args.bvthread:
test_bv_thread = TestBinaryValueThread(args.bvthread)
deferred(test_bv_thread.start)
_log.debug("running")
run(args.spin)
_log.debug("fini")
def main():
global test_ai, test_application
# make a parser
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"--console",
action="store_true",
default=False,
help="create a console",
)
# analog value task and thread
parser.add_argument(
"--aitask",
type=float,
help="analog input recurring task",
)
parser.add_argument(
"--aithread",
type=float,
help="analog input thread",
)
# analog value task and thread
parser.add_argument(
"--bvtask",
type=float,
help="binary value recurring task",
)
parser.add_argument(
"--bvthread",
type=float,
help="binary value thread",
)
# provide a different spin value
parser.add_argument(
"--spin",
type=float,
help="spin time",
default=1.0,
)
# 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 sample application
test_application = SubscribeCOVApplication(this_device, args.ini.address)
# make an analog value object
test_ai = AnalogInputObject(
objectIdentifier=("analogInput", 1),
objectName="ai",
presentValue=0.0,
covIncrement=0.5,
eventDetectionEnable=True,
eventEnable=[1, 1, 1],
ackedTransitions=[1, 1, 1],
notifyType=1,
reliability=1,
outOfService=False,
eventState=0,
statusFlags=[0, 0, 0, 0],
units=19,
)
_log.debug(" - test_ai: %r", test_ai)
# add it to the device
test_application.add_object(test_ai)
_log.debug(" - object list: %r", this_device.objectList)
# make a console
if args.console:
test_console = COVConsoleCmd()
_log.debug(" - test_console: %r", test_console)
# enable sleeping will help with threads
enable_sleeping()
# analog input task
if args.aitask:
test_ai_task = TestAnalogInputTask(args.aitask)
test_ai_task.install_task()
# analog input thread
if args.aithread:
test_ai_thread = TestAnalogInputThread(args.aithread)
deferred(test_ai_thread.start)
_log.debug("running")
run(args.spin)
_log.debug("fini")
def main():
global this_application, device_address, object_identifier, property_list
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"address",
help="device address",
)
parser.add_argument(
"objtype",
help="object types, e.g., analogInput",
)
parser.add_argument(
"objinstance",
type=int,
help="object instance",
)
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# interpret the address
device_address = Address(args.address)
if _debug: _log.debug(" - device_address: %r", device_address)
# build an identifier
object_identifier = (args.objtype, args.objinstance)
if _debug: _log.debug(" - object_identifier: %r", object_identifier)
# get the object class
object_class = get_object_class(args.objtype)
if _debug: _log.debug(" - object_class: %r", object_class)
# make a queue of the properties
property_list = deque(prop.identifier for prop in object_class.properties)
if _debug: _log.debug(" - property_list: %r", property_list)
# 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 = ReadPropertyApplication(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
# fire off a request when the core has a chance
deferred(this_application.next_request)
_log.debug("running")
run()
_log.debug("fini")
self.response_values.append(value)
# fire off another request
deferred(self.next_request)
#
# __main__
#
try:
# 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(
objectName=args.ini.objectname,
objectIdentifier=int(args.ini.objectidentifier),
maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted),
segmentationSupported=args.ini.segmentationsupported,
vendorIdentifier=int(args.ini.vendoridentifier),
def main():
global args, this_application
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
parser.add_argument(
"host", nargs='?',
help="listening address of server or 'any' (default %r)" % (SERVER_HOST,),
default=SERVER_HOST,
)
parser.add_argument(
"port", nargs='?', type=int,
help="server port (default %r)" % (SERVER_PORT,),
default=SERVER_PORT,
)
parser.add_argument(
"--idle-timeout", nargs='?', type=int,
help="idle connection timeout",
default=IDLE_TIMEOUT,
)
parser.add_argument(
"--hello", action="store_true",
default=False,
help="send a hello message to a client when it connects",
)
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 = BIPSimpleApplication(this_device, args.ini.address)
# extract the server address and port
host = args.host
if host == "any":
host = ''
server_address = (host, args.port)
if _debug: _log.debug(" - server_address: %r", server_address)
# create a director listening to the address
this_director = TCPServerDirector(server_address, idle_timeout=args.idle_timeout)
if _debug: _log.debug(" - this_director: %r", this_director)
# create a client
write_property_client = WritePropertyClient()
if _debug: _log.debug(" - write_property_client: %r", write_property_client)
# bind everything together
bind(write_property_client, this_director)
bind(WritePropertyASE(), this_director)
_log.debug("running")
run()
_log.debug("fini")
json.dump(result, self.wfile)
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
pass
#
# __main__
#
try:
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an option to override the port in the config file
parser.add_argument('--port', type=int,
help="override the port in the config file to PORT",
default=9000,
)
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=int(args.ini.objectidentifier),
maxApduLengthAccepted=int(args.ini.maxapdulengthaccepted),
segmentationSupported=args.ini.segmentationsupported,
vendorIdentifier=int(args.ini.vendoridentifier),
)
def main():
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("device_id", type=int,
help="Device ID of the target device" )
arg_parser.add_argument("--address",
help="Address of target device, may be needed to help route initial request to device." )
arg_parser.add_argument("--registry-out-file", type=argparse.FileType('wb'),
help="Output registry to CSV file",
default=sys.stdout )
arg_parser.add_argument("--driver-out-file", type=argparse.FileType('wb'),
help="Output driver configuration to JSON file.",
default=sys.stdout)
arg_parser.add_argument("--max-range-report", nargs='?', type=float,
help='Affects how very large numbers are reported in the "Unit Details" column of the output. '
'Does not affect driver behavior.',
default=1.0e+20 )
args = arg_parser.parse_args()
_log.debug("initialization")
_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 = SynchronousApplication(this_device, args.ini.address)
_log.debug("starting build")
result = get_iam(this_application, args.device_id, args.address)
# request = WhoIsRequest()
# request.pduDestination = target_address
# result = this_application.make_request(request, expect_confirmation = False)
# if not isinstance(result, IAmRequest):
# result.debug_contents()
# raise TypeError("Error making WhoIs request, try running again.")
# device_type, device_instance = result.iAmDeviceIdentifier
# if device_type != 'device':
# raise DecodingError("invalid object type")
target_address = result.pduSource
device_id = result.iAmDeviceIdentifier[1]
_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))
config_file_name = basename(args.registry_out_file.name)
config = {
"driver_config":{"device_address":str(target_address),
"device_id": device_id},
"driver_type":"bacnet",
"registry_config":"config://registry_configs/{}".format(config_file_name)
}
json.dump(config, args.driver_out_file,indent=4)
try:
device_name = read_prop(this_application, target_address, "device", device_id, "objectName")
_log.debug('device_name = ' + str(device_name))
except TypeError:
_log.debug('device missing objectName')
try:
device_description = read_prop(this_application, target_address, "device", device_id, "description")
_log.debug('description = ' + str(device_description))
except TypeError:
_log.debug('device missing description')
config_writer = DictWriter(args.registry_out_file,
('Reference Point Name',
'Volttron Point Name',
'Units',
'Unit Details',
'BACnet Object Type',
'Property',
'Writable',
'Index',
'Write Priority',
'Notes'))
config_writer.writeheader()
try:
objectCount = read_prop(this_application, target_address, "device", device_id, "objectList", index=0)
list_property = "objectList"
except TypeError:
objectCount = read_prop(this_application, target_address, "device", device_id, "structuredObjectList", index=0)
list_property = "structuredObjectList"
_log.debug('objectCount = ' + str(objectCount))
for object_index in xrange(1,objectCount+1):
_log.debug('object_device_index = ' + repr(object_index))
bac_object = read_prop(this_application,
target_address,
"device",
device_id,
list_property,
index=object_index)
obj_type, index = bac_object
try:
process_object(this_application, target_address, obj_type, index, args.max_range_report, config_writer)
except:
_log.debug("Unexpected error processing object: {} {}".format(obj_type, index))
_log.debug(traceback.format_exc())
def process_task(self):
if _debug: PrairieDog._debug("process_task")
sys.stdout.write("%d woof!\n" % (self.dog_number,))
#
# __main__
#
try:
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an argument for seconds per dog
parser.add_argument('seconds', metavar='N', type=int, nargs='+',
help='number of seconds for each dog',
)
# now parse the arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make some dogs
for i, sec in enumerate(args.seconds):
dog = PrairieDog(i, sec * 1000)
if _debug: _log.debug(" - dog: %r", dog)
_log.debug("running")
result = this_application.make_request(request)
if not isinstance(result, ReadPropertyACK):
result.debug_contents(file=sys.stderr)
raise TypeError("Error reading property")
# find the datatype
datatype = get_datatype(obj_type, prop_id)
return result.propertyValue.cast_out(datatype)
try:
# parse the command line arguments
arg_parser = ConfigArgumentParser(description=__doc__)
arg_parser.add_argument("address",
help="Address of target device" )
arg_parser.add_argument("out_file", nargs='?', type=argparse.FileType('wb'),
help="Optional output file for configuration",
default=sys.stdout )
arg_parser.add_argument("--max_range_report", nargs='?', type=float,
help='Affects how very large numbers are reported in the "Unit Details" column of the output. '
'Does not affect sMap driver behavior.',
default=1.0e+20 )
args = arg_parser.parse_args()
_log.debug("initialization")
_log.debug(" - args: %r", args)
# make a device object
from bacpypes.constructeddata import Array
from bacpypes.app import BIPSimpleApplication
from bacpypes.object import get_object_class, get_datatype
from bacpypes.local.device import LocalDeviceObject
# Initialization
# some debugging
_debug = True
_log = ModuleLogger(globals())
# settings
# parse the command line arguments
parser = ConfigArgumentParser(description=__doc__)
# add an option for the server host
parser.add_argument("--host", type=str, help="server host")
# add an option for the server port
parser.add_argument("--port", type=int, help="server port")
DEFAULT_CONFIG_PATH = r"./weather_config.ini"
# reference a simple application
this_application = None
server = None
# TODO
# Cache control heder?
# favorite icon
favicon = zlib.decompress(
b'x\x9c\xab\x983\n\x90\x00\x00\x9b,\xa5\x01'
)
