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 run_application(**kwargs):
'''
Running the base application for spoofing bacnet test_devices on the local network.
:param vendoridentifier:
:param segmentationsupported:
:param maxapdulength:
:param objectidentifier:
:param objectname:
:param ini: Ini parameters
:param objects: Objects to be attached to the device
:return:
'''
import netifaces
from ipaddress import IPv4Network
#Get IP of 'en0' interface.
wifi_ip = netifaces.ifaddresses('en0')[netifaces.AF_INET][0]
#Construct address of device.
address = wifi_ip['addr'] + "/" + str(
IPv4Network("0.0.0.0/" + wifi_ip['netmask']).prefixlen) + ":47808"
this_device = LocalDeviceObject(**kwargs)
this_application = DebugApplication(this_device, address)
if "objects" in kwargs.keys():
for object in kwargs["objects"]:
this_application.add_object(object)
enable_sleeping()
run()
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_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():
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():
global args
# build a parser for the command line arguments
parser = ArgumentParser(description=__doc__)
# sample additional argument to change the prompt
parser.add_argument(
"--prompt", type=str,
default="> ",
help="change the prompt",
)
# accept everything else
parser.add_argument('args', nargs=argparse.REMAINDER)
# parse the command line arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make a console
this_console = Shell()
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 = ArgumentParser(description=__doc__).parse_args()
global this_switch, this_console
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make some debugging terminals
debug1 = DebugTerm("a")
debug2 = DebugTerm("b")
# make a switch with them
this_switch = Switch(a=debug1, b=debug2)
if _debug: _log.debug(" this_switch: %r", this_switch)
# make a test console
this_console = TestConsoleCmd()
if _debug: _log.debug(" this_console: %r", this_console)
# bind the console to the top and bottom of the switch
bind(this_console, this_switch, this_console)
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
def main():
# build a parser for the command line arguments
parser = ArgumentParser(description=__doc__)
# sample additional argument to change the prompt
parser.add_argument(
"--prompt",
type=str,
default="> ",
help="change the prompt",
)
# parse the command line arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make a console
this_console = ConsoleCmdTemplate(prompt=args.prompt)
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
# 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 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 simple application
this_application = WhoIsRouterApplication(args.ini.address)
if _debug: _log.debug(" - this_application: %r", this_application)
# make a console
this_console = WhoIsRouterConsoleCmd()
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_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 simple application
this_application = WhoIsRouterApplication(args.ini.address,
bbmdAddress=Address(
args.ini.foreignbbmd),
bbmdTTL=int(args.ini.foreignttl))
if _debug: _log.debug(" - this_application: %r", this_application)
# make a console
this_console = WhoIsRouterConsoleCmd()
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
# 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():
# 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 - Not required for this simple console cmd
# this_device = LocalDeviceObject
# Initialize application - Not required for this simple console cmd
# this_application = SampleApplication(this_device, args.ini.address)
# Make Console
this_console = SampleConsoleCmd()
if _debug: _log.debug(" - this_console: %r", this_console)
# Sleeping with threads
enable_sleeping()
_log.debug("Running")
run()
_log.debug("Finish")
return None
def main():
# build a parser for the command line arguments
parser = ArgumentParser(description=__doc__)
# sample additional argument to change the prompt
parser.add_argument(
"--prompt", type=str,
default="> ",
help="change the prompt",
)
# parse the command line arguments
args = parser.parse_args()
if _debug: _log.debug("initialization")
if _debug: _log.debug(" - args: %r", args)
# make a console
this_console = ConsoleCmdTemplate(prompt=args.prompt)
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 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 this_application
global Dispositivos
args = ConfigArgumentParser(description=__doc__).parse_args()
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),
)
this_application = SubscribeCOVApplication(this_device, args.ini.address)
try:
ficheiro = open(this_file_path + "/" + "Config.csv", "r")
configs = ficheiro.read()
ficheiro.close()
numLinhas = 0
for linha in configs.split("\n"):
valores = {}
argumento = {}
objectos = {}
try:
if numLinhas == 0:
numLinhas += 1
pass
else:
DeviceID, IPort, ProcID, Object, ObjectID, Argument, VarName, DefaultVarValue, writeble = linha.split(
";")
valores["valorActual"] = int(DefaultVarValue)
valores["NomeVAR"] = VarName
valores["ProcID"] = int(ProcID)
valores["escrita"] = bool(int(writeble))
argumento[Argument] = valores
objectos[Object + "_" + ObjectID] = argumento
objectos["IPort"] = IPort
if not DeviceID in Dispositivos:
Dispositivos[DeviceID] = objectos
else:
Dispositivos[DeviceID].update(objectos)
numLinhas += 1
except:
pass #serve para ignorar a ultima linha que nao contem qualquer tipo de informacao util
except Exception as e:
with open("ErrorLog.txt", "a") as myfile:
myfile.write(
str(time.strftime("%d-%m-%Y %H:%M:%S")) +
" Failed to open configuration file.\n")
myfile.write("Error -> " + str(e) + "\n")
services_supported = this_application.get_services_supported()
this_device.protocolServicesSupported = services_supported.value
enable_sleeping()
subscribe_thread = SubscricaoDados()
SMmonitor_thread = ComunicacaoSM()
deferred(SMmonitor_thread.start)
deferred(subscribe_thread.start)
run()
def main():
global args, this_device, this_application
# build a parser, add some options
parser = ArgumentParser(description=__doc__)
parser.add_argument(
'--lan',
type=str,
default=default_lan_name,
help='lan name',
)
parser.add_argument(
'--host',
type=str,
default=default_broker_host,
help='broker host address',
)
parser.add_argument(
'--port',
type=int,
default=default_broker_port,
help='broker port',
)
parser.add_argument(
'--keepalive',
type=int,
default=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 simple application
this_application = MQTTSniffer(args.lan, args.host, args.port,
args.keepalive)
# enable sleeping will help with threads
enable_sleeping()
# start up the client
this_application.startup()
_log.debug("running")
run()
# shutdown the client
this_application.shutdown()
_log.debug("fini")
def _startAppThread(self):
"""
Starts the application in its own thread so requests can be processed.
Once started, socket will be reserved.
"""
print('Starting app...')
enable_sleeping(0.0005)
self.t = Thread(target=startBacnetIPApp, daemon = True)
self.t.start()
self._started = True
print('App started')
def _startAppThread(self):
"""
Starts the BACnet stack in its own thread so requests can be processed.
As signal cannot be called in another thread than the main thread
when calling startBacnetIPApp, we must pass None to both parameters
"""
self._log.info('Starting app...')
enable_sleeping(0.0005)
self.t = Thread(target=startBacnetIPApp, kwargs={'sigterm': None,'sigusr1': None}, daemon = True)
self.t.start()
self._started = True
self._log.info('BAC0 started')
def connect(self):
"""
:return:
"""
try:
self.this_device = LocalDeviceObject(
objectName=self.local_object_name,
objectIdentifier=self.boid,
maxApduLengthAccepted=int(self.max_APDU_length_accepted),
segmentationSupported=self.segmentation_supported,
vendorIdentifier=self.vendor_id,
vendorName=self.vendor_name,
modelName=self.model_name,
systemStatus=self.system_status,
description=
'PyScada BACnet DAQs Service (https://github.com/trombastic/pyscada)',
firmwareRevision=''.join(sys.version.split('|')[:2]),
applicationSoftwareVersion=pyscada.__version__,
protocolVersion=1,
protocolRevision=0,
)
self.this_application = BIPApplication(self.this_device,
self.local_ip)
app_type = 'Simple BACnet/IP App'
logger.debug("Starting")
try:
logger.info('Starting app...')
enable_sleeping(0.0005)
self.t = Thread(target=run,
kwargs={
'sigterm': None,
'sigusr1': None
},
daemon=True)
self.t.start()
logger.info('BAC0 started')
print("Registered as {}".format(app_type))
except:
logger.warning("Error opening socket")
raise
logger.debug("Running")
except Exception as error:
logger.error("an error has occurred: {}".format(error))
finally:
logger.debug("finally")
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)
this_application = BIPForeignApplication(
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 = WriteSomethingConsoleCmd()
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(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
# 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():
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
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),
}
if hasattr(args.ini, 'mstpdbgfile'):
mstp_args['_mstpdbgfile'] = str(args.ini.mstpdbgfile)
this_device = LocalDeviceObject(ini=args.ini, **mstp_args)
if _debug: _log.debug(" - this_device: %r", this_device)
# make a simple application
this_application = WhoIsIAmApplication(
this_device,
args.ini.address,
)
if _debug: _log.debug(" - this_application: %r", this_application)
# make a console
this_console = BacnetClientConsoleCmd()
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
# create a console log handler to show how settings are gathered from
# the JSON file. The settings may include debugging, so this is to
# debug the debugging and usually isn't necessary
ConsoleLogHandler("bacpypes.consolelogging")
# parse the command line arguments
args = JSONArgumentParser(description=__doc__).parse_args()
if _debug:
_log.debug("initialization")
if _debug:
_log.debug(" - args: %r", args)
local_device = args.json["local-device"]
if _debug:
_log.debug(" - local_device: %r", local_device)
# make a device object
this_device = LocalDeviceObject(**local_device)
if _debug:
_log.debug(" - this_device: %r", this_device)
# make a simple application
this_application = BIPSimpleApplication(this_device, local_device.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 _startAppThread(self):
"""
Starts the BACnet stack in its own thread so requests can be processed.
As signal cannot be called in another thread than the main thread
when calling startBacnetIPApp, we must pass None to both parameters
"""
self._log.info("Starting app...")
enable_sleeping(0.0005)
self.t = Thread(
target=startBacnetIPApp,
kwargs={"sigterm": None, "sigusr1": None},
daemon=True,
)
try:
self.t.start()
self._started = True
self._log.info("BAC0 started")
except OSError:
stopBacnetIPApp()
self.t.join()
raise
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 = SampleApplication(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 = SampleConsoleCmd()
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
def __init__(self,
logger: Logger,
ini_file: str = None,
config_file: str = None,
debug: bool = False
) -> None:
path = os.path.dirname(bnet_base.__file__)
self.ini_file = path + '/' + ini_file
self.config_file = path + '/' + config_file
self.debug = debug
self.logger = logger
self.logger.debug(f"init: bacpypes with {self.ini_file}")
cmd_line_args_simulated = []
if self.debug:
cmd_line_args_simulated.append("--debug")
cmd_line_args_simulated.append(__name__)
cmd_line_args_simulated.append("--ini")
cmd_line_args_simulated.append(self.ini_file)
self.args = ConfigArgumentParser().parse_args(cmd_line_args_simulated)
# load our reliable config file that has ports, names, types, etc.
self.bacnet_config = json.load(open(self.config_file, 'r'))
self.logger.debug(f"loaded {self.bacnet_config.get('name')}")
# make a device object
self.device = LocalDeviceObject(ini=self.args.ini)
# Overwrite the IP address in the .ini file to match what this machine
# is configured for (to work, it must be a static IP on the same
# subnet as the reliable / bacnet devices: 192.168.1.XXX/24
self.logger.debug(f"init: this host config IP {self.args.ini.address}")
# make an application to get callbacks from bacpypes
self.app = BIPSimpleApplication(self.device, self.args.ini.address)
enable_sleeping() # backpypes core threads: must do since django is multi threaded
self.taskman = TaskManager()
def _startAppThread(self):
"""
Starts the BACnet stack in its own thread so requests can be processed.
As signal cannot be called in another thread than the main thread
when calling startBacnetIPApp, we must pass None to both parameters
"""
self._log.info("Starting app...")
enable_sleeping(0.0005)
self.t = Thread(
target=startBacnetIPApp,
kwargs={
"sigterm": None,
"sigusr1": None
},
daemon=True,
)
try:
self.t.start()
self._started = True
self._log.info("BAC0 started")
except OSError:
stopBacnetIPApp()
self.t.join()
raise
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 = ReadPropertyAnyApplication(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 = ReadPropertyAnyConsoleCmd()
_log.debug("running")
# enable sleeping will allow handling of threads
enable_sleeping()
run()
except Exception as error:
_log.exception("an error has occurred: %s", error)
finally:
_log.debug("finally")
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():
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")
def main():
global args, this_application
# parse the command line arguments
parser = ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
# add an argument for interval
parser.add_argument(
"addr1",
type=str,
help="address of first network",
)
# add an argument for interval
parser.add_argument(
"net1",
type=int,
help="network number of first network",
)
# add an argument for interval
parser.add_argument(
"net2",
type=int,
help="network number of second network",
)
# add an argument for how many virtual devices
parser.add_argument(
"--count",
type=int,
help="number of virtual devices",
default=1,
)
# add an argument for how many virtual devices
parser.add_argument(
"--rpm",
help="enable read property multiple",
action="store_true",
)
# add an argument for including the property list
parser.add_argument(
"--plist",
help="enable property list property",
action="store_true",
)
# now parse the arguments
args = parser.parse_args()
if _debug:
_log.debug("initialization")
if _debug:
_log.debug(" - args: %r", args)
local_address = Address(args.addr1)
local_network = args.net1
vlan_network = args.net2
# 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_addr = Address(1)
router_node = Node(router_addr)
vlan.add_node(router_node)
# bind the router stack to the vlan network through this node
router.nsap.bind(router_node, vlan_network, router_addr)
# send network topology
deferred(router.nse.i_am_router_to_network)
# add the dynamic property list
if args.plist:
RandomAnalogValueObject.properties.append(CurrentPropertyList())
# register it now that all its properties are defined
register_object_type(RandomAnalogValueObject, vendor_id=999)
# console is the first device
device_number = 2
device_instance = vlan_network * 100 + device_number
_log.debug(" - console device_instance: %r", device_instance)
# make a vlan device object
vlan_device = LocalDeviceObject(
objectName="VLAN Console Node %d" % (device_instance, ),
objectIdentifier=("device", device_instance),
maxApduLengthAccepted=1024,
segmentationSupported="noSegmentation",
vendorIdentifier=15,
)
_log.debug(" - vlan_device: %r", vlan_device)
vlan_address = Address(device_number)
_log.debug(" - vlan_address: %r", vlan_address)
# make the console application, add it to the network
this_application = VLANConsoleApplication(vlan_device, vlan_address)
vlan.add_node(this_application.vlan_node)
_log.debug(" - this_application: %r", this_application)
# make a console
this_console = VLANConsoleCmd()
if _debug:
_log.debug(" - this_console: %r", this_console)
# make a random value object
ravo = RandomAnalogValueObject(
objectIdentifier=("analogValue", 1),
objectName="Random-1-%d" % (device_instance, ),
)
_log.debug(" - ravo: %r", ravo)
# add it to the device
this_application.add_object(ravo)
# make some more devices
for device_number in range(3, 3 + args.count - 1):
# device identifier is assigned from the address
device_instance = vlan_network * 100 + device_number
_log.debug(" - device_instance: %r", device_instance)
# make a vlan device object
vlan_device = LocalDeviceObject(
objectName="VLAN Node %d" % (device_instance, ),
objectIdentifier=("device", device_instance),
maxApduLengthAccepted=1024,
segmentationSupported="noSegmentation",
vendorIdentifier=15,
)
_log.debug(" - vlan_device: %r", vlan_device)
vlan_address = Address(device_number)
_log.debug(" - vlan_address: %r", vlan_address)
# make the application, add it to the network
vlan_app = VLANApplication(vlan_device, vlan_address)
vlan.add_node(vlan_app.vlan_node)
_log.debug(" - vlan_app: %r", vlan_app)
# make a random value object
ravo = RandomAnalogValueObject(
objectIdentifier=("analogValue", 1),
objectName="Random-1-%d" % (device_instance, ),
)
_log.debug(" - ravo: %r", ravo)
# add it to the device
vlan_app.add_object(ravo)
# enable sleeping will help with threads
enable_sleeping()
_log.debug("running")
run()
_log.debug("fini")
