def createNetwork(options, log=None, autostart=True, kvals=True): network = ZWaveNetwork(options, log=None) time_started = 0 for i in range(0, 100): if network.state >= network.STATE_AWAKED: break else: time_started += 1 time.sleep(1.0) if network.state < network.STATE_AWAKED: print("Network is not awake but continue anyway") for i in range(0, 300): if network.state >= network.STATE_READY: print("home ID {}".format(home_id)) break else: sys.stdout.write(".") time_started += 1 #sys.stdout.write(network.state_str) #sys.stdout.write("(") #sys.stdout.write(str(network.nodes_count)) #sys.stdout.write(")") #sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) if not network.is_ready: print("network is not ready but start anyway") network.start() return network
def startup_zwave(self, args={}): ffEvent(self._id,{'zwave':'starting_up'}) zwaveSetup = ZWaveOption(self._port, self._configFile) zwaveSetup.set_console_output(False) zwaveSetup.lock() network = ZWaveNetwork(zwaveSetup, autostart=False) network.start() stdout.write("Waking up Zwave (This can take up to 5 minutes)") for i in xrange(3): if network.state >= network.STATE_AWAKED: logging.info('Zwave Network Awake') break else: stdout.write(".") stdout.flush() sleep(1) for x in xrange(3): if network.state >= network.STATE_READY: ffEvent(self._id,{'zwave':'network_ready'}) else: stdout.write(".") stdout.flush() sleep(.5) return network
class HomeManager(object): def __init__(self, device_path, ozw_log_level, logger): self.logger = logger options = ZWaveOption(device_path, config_path="./venv/lib/python3.6/site-packages/python_openzwave/ozw_config", user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_save_log_level(ozw_log_level) options.set_console_output(False) options.set_logging(True) options.lock() self.options = options self.network = ZWaveNetwork(options, log=None, autostart=False) self.client = InfluxDBClient(database=DATABASE) def start(self): self.logger.info("Starting network...") self.network.start() def stop_signal(self, signum, frame): self.stop() def stop(self): self.logger.info("Stopping network...") self.network.nodes[3].values[72057594098484979].data = 3600 self.network.stop() self.logger.info("Stopped") def connect_signals(self): dispatcher.connect(self.signal_network_ready, self.network.SIGNAL_NETWORK_READY) signal.signal(signal.SIGINT, self.stop_signal) # Note -- the name of the network parameter must not change! def signal_network_ready(self, network): if self.network is not network: return else: del network ozw_debug(self.logger, self.network) self.logger.info("Network is ready!") self.network.nodes[3].values[72057594098484979].data = 15 self.start_polling() @staticmethod def is_sensor(node): return isinstance(node, ZWaveNodeSensor) and not len(node.get_sensors()) is 0 def start_polling(self): Timer(TIME_INTERVAL, self.start_polling).start() labels_to_be_polled = {'Luminance', 'Relative Humidity', 'Temperature', 'Ultraviolet', 'Alarm Level', 'Burglar'} for node_id, node in self.network.nodes.items(): if self.is_sensor(node): for val_id in self.network.nodes[node_id].values: val = self.network.nodes[node_id].values[val_id] if val.label in labels_to_be_polled: self.logger.info("Received value refresh %s: %s", val.id_on_network, val) self.client.write_points(value_refresh_to_influxdb_json(node, val))
def setup(self, updateCallback): dispatcher.connect(self.onNetworkReady, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self.onNetworkStart, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.onNetworkFailed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) # TODO: make udev.symlink rule to a specific port (USB0/1) # Uncomment this to run on PC (remember to update the zwave config path) #options = ZWaveOption("/dev/ttyUSB0", \ # config_path="/home/<USER>/software/python-openzwave-0.2.6/openzwave/config", \ options = ZWaveOption("/dev/serial/by-path/platform-bcm2708_usb-usb-0:1.2:1.0-port0", \ config_path="/home/pi/software/python-openzwave-0.2.6/openzwave/config", \ user_path=".", cmd_line="") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Debug') options.set_poll_interval(30); options.set_suppress_value_refresh(False) options.addOptionBool("AssumeAwake", True) options.set_logging(False) options.lock() self.network = ZWaveNetwork(options, autostart=False) self.onDeviceUpdateCallback = updateCallback self.network.start() self.addedConnections = False Timer(2*60, self.setupConnections).start()
def test_000_network_start_stop(self): self.driver_ready = False self.driver_removed = False self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() dispatcher.connect(self.driver_ready_message, ZWaveNetwork.SIGNAL_DRIVER_READY) dispatcher.connect(self.driver_removed_message, ZWaveNetwork.SIGNAL_DRIVER_REMOVED) self.network = ZWaveNetwork(self.options) for i in range(0, SLEEP): if self.network.state>=self.network.STATE_AWAKED: break else: time.sleep(1.0) self.assertTrue(self.driver_ready) self.network.stop() for i in range(0, SLEEP): if self.network.state==self.network.STATE_STOPPED: break else: time.sleep(1.0) self.assertEqual(self.network.state, self.network.STATE_STOPPED) #self.assertTrue(self.driver_removed) self.network = None
def network_init(self): """ Zwave network initialization. Terminate program if initialization failed. """ logging.basicConfig(level=logging.INFO) logger = logging.getLogger('openzwave') # option initialization, abort if initialization failed try: options = ZWaveOption(self.device, \ config_path="../openzwave/config", \ user_path=".", cmd_line="") options.set_log_file(self.log_file) options.set_append_log_file(self.write_file) options.set_console_output(self.output_console) options.set_save_log_level(self.log) options.set_logging(False) options.lock() except Exception as e: print( "Zwave initialization failed! \nPlease listen the USB port of zwave stick!" ) print(e) sys.exit(-1) # create a network instance self.network = ZWaveNetwork(options, log=None)
def start(self, controllerDevice, config_path="./config", user_path=".", cmd_line=""): self.options = ZWaveOption(controllerDevice, config_path, user_path, cmd_line) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("None") self.options.set_logging(True) self.options.lock() dispatcher.connect(self.zwave_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self.zwave_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.zwave_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.zwave_node_update, ZWaveNetwork.SIGNAL_NODE) dispatcher.connect(self.zwave_value_update, ZWaveNetwork.SIGNAL_VALUE) self.network = ZWaveNetwork(self.options, autostart=False) self.network.start()
def run(self): # Connect to mqtt self.setup_mqtt() # Create a network object self.network = ZWaveNetwork(options, autostart=False) # Hook Ctrl-C to cleanly shutdown. # This ensures openzwave persists its state to the zwcfg xml file. def signal_handler(signal, frame): default_logger.info("Stopping zwave network") self.network.stop() default_logger.info("Stopping mqtt client") self.client.disconnect() signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGTERM, signal_handler) dispatcher.connect(self.network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.network_ready, ZWaveNetwork.SIGNAL_AWAKE_NODES_QUERIED) self.network.start() self.client.loop_forever() default_logger.info("Finished")
def run(self): """ Run method for the plugin """ self.logger.debug('zwave: run method called') self.alive = True try: options = ZWaveOption(self._device, config_path=self._config_path, user_path='.', cmd_line='') except Exception as e: self.logger.error('zwave: error on create ZWaveOption - {}'.format(e)) self.alive = False return try: options.set_log_file(self._logfile) options.set_save_log_level(self._loglevel) options.set_logging(self._logging) options.set_append_log_file(False) options.set_console_output(False) options.set_security_strategy(self._sec_strategy) options.lock() except Exception as e: self.logger.error('zwave: error on option.set_* - {}'.format(e)) self.logger.debug('zwave: run -> create network') try: self._network = ZWaveNetwork(options, autostart=False) except Exception as e: self.logger.error('zwave: error on create Network Object - {}'.format(e)) self.logger.debug('zwave: run -> connect event handler') try: dispatcher.connect(self.zwave_value_update, ZWaveNetwork.SIGNAL_VALUE_CHANGED) except Exception as e: self.logger.error('zwave: error on connect event handler - {}'.format(e)) self.logger.debug('zwave: run -> start network') try: self._network.start() except Exception as e: self.logger.error('zwave: error on start network - {}'.format(e)) self.logger.info('zwave: use openzwave library: {}'.format(self._network.controller.ozw_library_version)) self.logger.info('zwave: use python library: {}'.format(self._network.controller.python_library_version)) self.logger.info('zwave: use ZWave library: {}'.format(self._network.controller.library_description)) while 1: if self.alive and self._network.state < self._network.STATE_READY: self.logger.debug('zwave: wait until network is ready... current state is: {}'.format(self._network.state_str)) time.sleep(3.0) if self._network.state == self._network.STATE_FAILED: self.alive = false return self.logger.info('zwave: controller ready : {} nodes were found.'.format(self._network.nodes_count)) self.logger.info('zwave: controller node id : {}'.format(self._network.controller.node.node_id)) self.logger.info('zwave: controller node version : {}'.format(self._network.controller.node.version)) self.logger.info('zwave: Network home id : {}'.format(self._network.home_id_str)) self.logger.info('zwave: Nodes in network : {}'.format(self._network.nodes_count))
def __init__(self): ###### options needed for python openzwave library like config files path, logging, device = configpi.interface options = ZWaveOption( device, config_path="/home/pi/IoTLab/python-openzwave/openzwave/config", user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Warning') options.set_logging(True) options.lock() # creation of the object network using the options entity already created self.network = ZWaveNetwork(options, autostart=False) ###### These dispatchers associate a method to a signal. the signals are generated by the library python-openzwave. ###### Once the signal is received. It's associated method is executed (see "_node_added" example below in "_network_started" method) dispatcher.connect(self._network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self._network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) ###### backend object attributes # self.devices = OrderedDict() ### will contain the list of nodes in the network # self.sensors = OrderedDict() ### will contain the list of sensors (only) in the network self.node_added = False self.node_removed = False self.timestamps = { } ### will contain the time of the last values' update for each sensor self.queryStages = { ### the diffrent stages that a node object gets through before being ready "None": 1, # Query process hasn't started for this node "ProtocolInfo": 2, # Retrieve protocol information "Probe": 3, # Ping device to see if alive "WakeUp": 4, # Start wake up process if a sleeping node "ManufacturerSpecific1": 5, # Retrieve manufacturer name and product ids if ProtocolInfo lets us "NodeInfo": 6, # Retrieve info about supported, controlled command classes "SecurityReport": 7, # Retrieve a list of Command Classes that require Security "ManufacturerSpecific2": 8, # Retrieve manufacturer name and product ids "Versions": 9, # Retrieve version information "Instances": 10, # Retrieve information about multiple command class instances "Static": 11, # Retrieve static information (doesn't change) "Probe1": 12, # Ping a device upon starting with configuration "Associations": 13, # Retrieve information about associations "Neighbors": 14, # Retrieve node neighbor list "Session": 15, # Retrieve session information (changes infrequently) "Dynamic": 16, # Retrieve dynamic information (changes frequently) "Configuration": 17, # Retrieve configurable parameter information (only done on request) "Complete": 18 # Query process is completed for this node }
def start(self): if not self.opts_locked: raise ZWaveCentralException("ZWave options not locked") self.net = ZWaveNetwork(self.opts, autostart=False) self.ctrl.append(self.net.controller) self.home_id = self.net.home_id self.net.start()
def __init__(self, object_group, config): Plugin.__init__(self, config=config, object_group=object_group, plugin_name=PLUGIN_NAME) # Get parameters from the config file if not self.is_enabled(): return # Initialize zwave library # Options try: opts = ZWaveOption( device="/dev/ttyUSB0", config_path= "/home/mlamonta/git/python-openzwave/openzwave/config/", user_path="logs") opts.set_log_file("./logs/zwave.log") opts.set_save_log_level("Alert") opts.set_append_log_file(False) opts.set_console_output(False) opts.set_logging(True) opts.lock() except ZWaveException as e: self.logger.error(str(e)) return # Network self.net = ZWaveNetwork(opts) self.logger.info( "------------------------------------------------------------") self.logger.info("Waiting for network awake : ") self.logger.info( "------------------------------------------------------------") for i in range(0, 300): if self.net.state >= self.net.STATE_AWAKED: self.logger.info("done") break else: time.sleep(1.0) if self.net.state < self.net.STATE_AWAKED: self.logger.warning("Network is not awake") return self.logger.info( "------------------------------------------------------------") for node in self.net.nodes: self.logger.info("%s - %s / %s" % (self.net.nodes[node].node_id, self.net.nodes[node].manufacturer_name, self.net.nodes[node].product_name)) self._initialized = True
def run(self): self.isRunning = True #Create a network object self.network = ZWaveNetwork(self.zwaveOptions, autostart=False) #and connect our above handlers to respective events dispatcher.connect(self.networkStarted, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.networkFailed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.networkReady, ZWaveNetwork.SIGNAL_NETWORK_READY) self.network.start()
class TestApi(TestPyZWave): """ Parent test class for api """ @classmethod def setUpClass(self): super(TestApi, self).setUpClass() self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() self.ctrl_command_result = None dispatcher.connect(self.ctrl_message, ZWaveController.SIGNAL_CONTROLLER) self.node_result = None dispatcher.connect(self.node_update, ZWaveNetwork.SIGNAL_NODE) self.network = ZWaveNetwork(self.options) time.sleep(1.0) @classmethod def tearDownClass(self): self.network.stop() time.sleep(2.0) super(TestApi, self).tearDownClass() self.network=None def setUp(self): self.wait_for_network_state(self.network.STATE_AWAKED, 1) def wait_for_queue(self): for i in range(0,60): if self.network.controller.send_queue_count <= 0: break else: time.sleep(0.5) def wait_for_network_state(self, state, multiply=1): for i in range(0,SLEEP*multiply): if self.network.state>=state: break else: #sys.stdout.write(".") #sys.stdout.flush() time.sleep(1.0) def ctrl_message(self, state, message, network, controller): self.ctrl_command_result = state def node_update(self, network, node): self.node_result = node
class TestApi(TestPyZWave): """ Parent test class for api """ @classmethod def setUpClass(self): super(TestApi, self).setUpClass() self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options) self.ctrl_command_result = None dispatcher.connect(self.ctrl_message, ZWaveController.SIGNAL_CONTROLLER) self.node_result = None dispatcher.connect(self.node_update, ZWaveNetwork.SIGNAL_NODE) @classmethod def tearDownClass(self): self.network.stop() super(TestApi, self).tearDownClass() def setUp(self): self.wait_for_network_state(self.network.STATE_AWAKED, 1) def wait_for_queue(self): for i in range(0, 60): if self.network.controller.send_queue_count <= 0: break else: time.sleep(0.5) def wait_for_network_state(self, state, multiply=1): for i in range(0, SLEEP * multiply): if self.network.state >= state: break else: #sys.stdout.write(".") #sys.stdout.flush() time.sleep(1.0) def ctrl_message(self, state, message, network, controller): self.ctrl_command_result = state def node_update(self, network, node): self.node_result = node
def setUpClass(self): super(TestApi, self).setUpClass() self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(self.ozwout) self.options.set_save_log_level(self.ozwlog) self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options) self.node_result = None self.ctrl_command_result = None self.ctrl_command_signal = None #dispatcher.connect(self.ctrl_message, ZWaveNetwork.SIGNAL_CONTROLLER_COMMAND) time.sleep(1.0)
def setUpClass(self): super(TestApi, self).setUpClass() self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options) self.ctrl_command_result = None dispatcher.connect(self.ctrl_message, ZWaveController.SIGNAL_CONTROLLER) self.node_result = None dispatcher.connect(self.node_update, ZWaveNetwork.SIGNAL_NODE)
def __init__(self, device_path, ozw_log_level, logger): self.logger = logger options = ZWaveOption(device_path, config_path="./venv/lib/python3.6/site-packages/python_openzwave/ozw_config", user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_save_log_level(ozw_log_level) options.set_console_output(False) options.set_logging(True) options.lock() self.options = options self.network = ZWaveNetwork(options, log=None, autostart=False) self.client = InfluxDBClient(database=DATABASE)
class TestNetworkStartStop(TestPyZWave): @classmethod def setUpClass(self): super(TestNetworkStartStop, self).setUpClass() self.options = None self.network = None @classmethod def tearDownClass(self): if self.network is not None: self.network.stop() super(TestNetworkStartStop, self).tearDownClass() def test_000_network_start_stop(self): self.driver_ready = False self.driver_removed = False self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() dispatcher.connect(self.driver_ready_message, ZWaveNetwork.SIGNAL_DRIVER_READY) dispatcher.connect(self.driver_removed_message, ZWaveNetwork.SIGNAL_DRIVER_REMOVED) self.network = ZWaveNetwork(self.options) for i in range(0, SLEEP): if self.network.state>=self.network.STATE_AWAKED: break else: time.sleep(1.0) self.assertTrue(self.driver_ready) self.network.stop() for i in range(0, SLEEP): if self.network.state==self.network.STATE_STOPPED: break else: time.sleep(1.0) self.assertEqual(self.network.state, self.network.STATE_STOPPED) #self.assertTrue(self.driver_removed) self.network = None def driver_ready_message(self, network, controller): self.driver_ready = True def driver_removed_message(self, network): self.driver_removed = True
def start_zwave(): network = ZWaveNetwork(options, log=None) print("Starting event registration:") dispatcher.connect(louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) print("First evenbt registered") dispatcher.connect(louie_network_resetted, ZWaveNetwork.SIGNAL_NETWORK_RESETTED) print("Second evenbt registered") dispatcher.connect(louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) print("Event registration done") time_started = 0 print("------------------------------------------------------------") print("Waiting for network awaked : ") print("------------------------------------------------------------") for i in range(0, 300): if network.state >= network.STATE_AWAKED: print("Network initialization done") print("Memory use : {} Mo".format( (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0))) break else: sys.stdout.write(".") sys.stdout.flush() time_started += 1 time.sleep(1.0) print("Network is not awake " + str(i)) if network.state < network.STATE_AWAKED: print(".") print("Network is not awake but continue anyway") print("End of start") return network
def __init__(self, name, location, nodefilename="/opt/seciot/nodenames.json"): IOTDeviceController.__init__(self, name) # Restore node stuff nodefile = open(nodefilename, "r") nodejson = nodefile.read() self.node_dict = json.loads(nodejson) # Init options device = "/dev/ttyACM0" sniff = 300.0 options = ZWaveOption(device, config_path="/opt/openzwave/config", user_path=".", cmd_line="") options.set_logging(False) options.set_console_output(False) options.lock() # Create a network object self.network = ZWaveNetwork(options, autostart=False) self.network.set_poll_interval(10, True) # We connect to the louie dispatcher dispatcher.connect(self.louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) self.network.start() # We wait for the network. print "***** Waiting for network to become ready : " for i in range(0, 300): if self.network.state >= self.network.STATE_READY: print "***** Network is ready" break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) # We update the name of the controller self.network.controller.node.name = name self.network.controller.node.location = location
def __init__(self): self.sensor_events = [] self.device = "/dev/ttyACM0" config_path = "plugins/python-openzwave/openzwave/config" user_path = "plugins/python-openzwave/config" # If using older Z-sticks, use the below device: # self.device = "/dev/ttyUSB0" # Change config paths where appropriate self.options = ZWaveOption(self.device, config_path=config_path, user_path=user_path, cmd_line="") # Turn off ozw console output self.options.set_console_output(False) self.options.set_save_log_level("Info") self.options.set_logging(False) self.options.lock() self.manager = libopenzwave.PyManager() self.manager.create() self.manager.addWatcher(self.event_callback) self.manager.addDriver(self.device) print("Starting Z-Wave Network...") self.network = ZWaveNetwork(self.options, log=None) # Wait for network to start while not self.network.state >= self.network.STATE_AWAKED: time.sleep(1) print("Z-Wave Network Started")
def init_zwave_network(device=None, config_path=None, user_path=None, debug=False): options = ZWaveOption(device, config_path=config_path, user_path=user_path, cmd_line="") options.set_log_file(os.path.join(user_path, "OZW_Log.log")) options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Info') # ('Info' if debug else 'Warning') options.set_logging(True) options.lock() zwave_network = ZWaveNetwork(options, autostart=False) # We connect to the louie dispatcher dispatcher.connect(zwave_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(zwave_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(zwave_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) return zwave_network
def connect(self) -> None: options = ZWaveOption( self.__zwave_config.port, config_path=self.__zwave_config.openzwave_config_path, user_path=".", cmd_line="") options.set_console_output(False) options.set_save_log_level("None") options.set_logging(False) options.lock() self.__network = ZWaveNetwork(options, autostart=False) dispatcher.connect(self.__network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.__network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self.__value_update, ZWaveNetwork.SIGNAL_VALUE) self.__network.start()
def __init__(self, *args, **kwargs): self._serialDevicePath = kwargs.get('serialDevicePath', None) self._options = ZWaveOption(self._serialDevicePath, \ config_path="/usr/local/etc/openzwave/", \ user_path=".", cmd_line="") self._options.set_log_file("OZW_Log.log") self._options.set_append_log_file(False) self._options.set_console_output(False) #self._options.set_save_log_level(log) self._options.set_save_log_level('Info') self._options.set_logging(True) self._options.set_notify_transactions(True) self._options.lock() self._network = ZWaveNetwork(self._options, log=None,autostart=False) dispatcher.connect(self.louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) self._network.start() super(Open_zwave, self).__init__(self, *args, **kwargs)
def start_zwnetwork(app): options = ZWaveOption(device=app.config['ZWAVE_DEVICE'], config_path=app.config['ZWAVE_DIR'], user_path=app.config['USER_DIR']) options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level(app.config['ZWAVE_DEBUG']) options.set_logging(app.config['ZWAVE_LOGGING']) options.lock() zwnetwork = ZWaveNetwork(options) return zwnetwork
def main(): global LIGHT, PUSHOVER logging.basicConfig(level=logging.INFO, format="%(asctime)-15s %(levelno)d %(message)s") # TODO: Put in argparse device = None if device is None: device = discover_device() check_device(device) CONFIG = read_config("config.json") if CONFIG.pushover.apikey is not None: logging.info("Setting up Pushover") PUSHOVER = Pushover(CONFIG.pushover.apikey, CONFIG.pushover.userkeys) connect_signals() options = create_zwave_options(device=device) network = ZWaveNetwork(options, log=None, autostart=False) queue = threading.Thread(target=DataQueue.worker, kwargs={"location": "home.db"}, name="db") queue.start() try: network.start() # Start REPL with a union where globals override locals local = locals().copy() local.update(globals()) code.interact(local=local) except KeyboardInterrupt: pass finally: logging.info("\nStopping network ...") network.stop() logging.info("Stopping data queue ...") DataQueue.stop() queue.join()
def test_000_api_network(self): self.touchFile('ttyUSBO_fake') self.options = ZWaveOption(device='ttyUSBO_fake', user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Debug") self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options, autostart=False) self.rmFile('ttyUSBO_fake')
def __init__(self): #super(, self).__init__() options = ZWaveOption(device, \ user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(True) options.set_save_log_level(log) #options.set_save_log_level('Info') options.set_logging(False) options.lock() self._optiton = options self.network = ZWaveNetwork(options, log=None) time_started = 0 for i in range(0,100): if self.network.state>=self.network.STATE_AWAKED: break else: time_started += 1 time.sleep(1.0) if self.network.state<self.network.STATE_AWAKED: print("Network is not awake but continue anyway") for i in range(0,300): if self.network.state>=self.network.STATE_READY: print("home ID {}".format(home_id)) break else: sys.stdout.write(".") time_started += 1 #sys.stdout.write(network.state_str) #sys.stdout.write("(") #sys.stdout.write(str(network.nodes_count)) #sys.stdout.write(")") #sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) if not network.is_ready: print("network is not ready but start anyway") network.start() self.controller = network.controller
def __init__(self, device_path, ozw_log_level, logger): self.logger = logger options = ZWaveOption( device_path, config_path= "./venv/lib/python3.%d/site-packages/python_openzwave/ozw_config" % sys.version_info[1], user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_save_log_level(ozw_log_level) options.set_console_output(False) options.set_logging(True) options.lock() self.options = options self.network = ZWaveNetwork(options, log=None, autostart=False) self.csvfile = open('output.csv', 'a') self.writer = csv.writer(self.csvfile) self.stopping = False
def _start_network(self): #Define some manager options self.options = ZWaveOption(self.device, \ config_path="openzwave/config", \ user_path=".", cmd_line="") self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level("Internal") self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options, self.log) self.status_bar.update(status='Start Network')
def _startNetwork(self): dispatcher.connect(self._notifyDriverReady, ZWaveNetwork.SIGNAL_DRIVER_READY) dispatcher.connect(self._notifyNetworkReady, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self._notifyNetworkFailed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self._notifyNodeReady, ZWaveNetwork.SIGNAL_NODE_READY) dispatcher.connect(self._notifyValueChanged, ZWaveNetwork.SIGNAL_VALUE_CHANGED) dispatcher.connect(self._notifyNodeAdded, ZWaveNetwork.SIGNAL_NODE_ADDED) self._initDialog(10, 60, ['Cancel'], 'Progress') self._addDialogText(2, 'Initializing OpenZWave') self._log.info('Initializing OpenZWave') self._network = ZWaveNetwork(self._options, log=self._log) #self._network = ZWaveWrapper.getInstance(device=self._config['device'], config=self._config['config'], log=None) self._setTimer('initCheck', 3, self._checkIfInitialized) while not self._stop.isSet() and not self._driverInitialized: time.sleep(0.1)
def _start_network(self): #Define some manager options self.options = ZWaveOption(self.device, \ config_path=self.config_path, \ user_path=self.user_path, cmd_line="") self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level(self.loglevel_ow) self.options.set_logging(True) self.options.lock() self.network = ZWaveNetwork(self.options, self.log, kvals=False) self.status_bar.update(status='Start Network')
def setup(self): self.logs = myLogs('zwave-daemon') device = "/dev/ttyUSB0" log = "Info" # Debug #Define some manager options # see docs at the end of file options = ZWaveOption(device, \ #config_path="openzwave/config", \ user_path="/home/scripts/zwave/home",\ cmd_line="" ) #options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('None') #options.set_queue_log_level("None") #options.set_save_log_level('Info') options.set_logging(False) options.lock() self.ZWave = ZWaveNetwork(options, log=None, autostart=False)
def __init__(self): ################### instanciation de l'objet backend ######################################################## ###### options needed for python openzwave library like config files path, logging, device = configpi.interface options = ZWaveOption(device, config_path="/home/pi/git-repo/python-openzwave/openzwave/config", user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Warning') options.set_logging(True) options.lock() # creation of the object network using the options entity already created self.network = ZWaveNetwork(options, autostart=False) ###### These dispatchers associate a method to a signal. the signals are generated by the library python-openzwave. ###### Once the signal is reveived. It's associated method is executed (see "_node_added" example below in "_network_started" method) dispatcher.connect(self._network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self._network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self._network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) ###### backend object attributes # self.devices = OrderedDict() ### will contain the list of nodes in the network # self.sensors = OrderedDict() ### will contain the list of sensors (only) in the network self.node_added = False self.node_removed = False self.timestamps = {} ### will contain the time of the last values' update for each sensor self.queryStages = { ### the diffrent stages that a node object gets through before being ready "None" : 1, # Query process hasn't started for this node "ProtocolInfo" : 2, # Retrieve protocol information "Probe" : 3, # Ping device to see if alive "WakeUp" : 4, # Start wake up process if a sleeping node "ManufacturerSpecific1" : 5, # Retrieve manufacturer name and product ids if ProtocolInfo lets us "NodeInfo" : 6, # Retrieve info about supported, controlled command classes "SecurityReport" : 7, # Retrieve a list of Command Classes that require Security "ManufacturerSpecific2" : 8, # Retrieve manufacturer name and product ids "Versions" : 9, # Retrieve version information "Instances" : 10, # Retrieve information about multiple command class instances "Static" : 11, # Retrieve static information (doesn't change) "Probe1" : 12, # Ping a device upon starting with configuration "Associations" : 13, # Retrieve information about associations "Neighbors" : 14, # Retrieve node neighbor list "Session" : 15, # Retrieve session information (changes infrequently) "Dynamic" : 16, # Retrieve dynamic information (changes frequently) "Configuration" : 17, # Retrieve configurable parameter information (only done on request) "Complete" : 18 # Query process is completed for this node }
def __init__(self, object_group, config): Plugin.__init__(self, config=config, object_group=object_group, plugin_name=PLUGIN_NAME) # Get parameters from the config file if not self.is_enabled(): return # Initialize zwave library # Options try: opts = ZWaveOption(device="/dev/ttyUSB0", config_path="/home/mlamonta/git/python-openzwave/openzwave/config/", user_path="logs") opts.set_log_file("./logs/zwave.log") opts.set_save_log_level("Alert") opts.set_append_log_file(False) opts.set_console_output(False) opts.set_logging(True) opts.lock() except ZWaveException as e: self.logger.error(str(e)) return # Network self.net = ZWaveNetwork(opts) self.logger.info("------------------------------------------------------------") self.logger.info("Waiting for network awake : ") self.logger.info("------------------------------------------------------------") for i in range(0, 300): if self.net.state >= self.net.STATE_AWAKED: self.logger.info("done") break else: time.sleep(1.0) if self.net.state < self.net.STATE_AWAKED: self.logger.warning("Network is not awake") return self.logger.info("------------------------------------------------------------") for node in self.net.nodes: self.logger.info("%s - %s / %s" % (self.net.nodes[node].node_id, self.net.nodes[node].manufacturer_name, self.net.nodes[node].product_name) ) self._initialized = True
def __init__(self): device = "/dev/ttyUSB0" options = ZWaveOption(device, config_path="/home/rich/openzwave/config", user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Debug') options.set_logging(True) options.lock() self.values = {} dispatcher.connect(self._network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self._network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self._network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) self.network = ZWaveNetwork(options, autostart=False)
def setUpClass(self): super(TestApi, self).setUpClass() self.options = ZWaveOption(device=self.device, user_path=self.userpath) self.options.set_log_file("OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(self.ozwout) self.options.set_save_log_level(self.ozwlog) self.options.set_logging(True) self.options.lock() self.node_result = None dispatcher.connect(self.node_update, ZWaveNetwork.SIGNAL_NODE) self.network = ZWaveNetwork(self.options) self.ctrl_command_result = None self.ctrl_command_signal = None #dispatcher.connect(self.ctrl_message, ZWaveNetwork.SIGNAL_CONTROLLER_COMMAND) time.sleep(1.0)
def _startNetwork(self): dispatcher.connect(self._notifyDriverReady, ZWaveNetwork.SIGNAL_DRIVER_READY) dispatcher.connect(self._notifyNetworkReady, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self._notifyNetworkFailed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self._notifyNodeReady, ZWaveNetwork.SIGNAL_NODE_READY) dispatcher.connect(self._notifyValueChanged, ZWaveNetwork.SIGNAL_VALUE_CHANGED) dispatcher.connect(self._notifyNodeAdded, ZWaveNetwork.SIGNAL_NODE_ADDED) self._initDialog(10,60,['Cancel'],'Progress') self._addDialogText(2,'Initializing OpenZWave') self._log.info('Initializing OpenZWave') self._network = ZWaveNetwork(self._options, log=self._log) #self._network = ZWaveWrapper.getInstance(device=self._config['device'], config=self._config['config'], log=None) self._setTimer('initCheck', 3, self._checkIfInitialized) while not self._stop.isSet() and not self._driverInitialized: time.sleep(0.1)
def __init__(self, device, isac_node): self.isac_node = isac_node self.signals = {} self._ozw_notif_queue = Queue() self._running = True green.spawn(self._notif_reader) self.options = ZWaveOption( device, config_path='/usr/share/openzwave/config', user_path='./user-dir', cmd_line='' ) self.options.set_log_file("./user-dir/OZW_Log.log") self.options.set_append_log_file(False) self.options.set_console_output(False) self.options.set_save_log_level('Info') self.options.set_logging(False) self.options.lock() self.network = ZWaveNetwork(self.options, log=None) notif_to_func = [ (ZWaveNetwork.SIGNAL_NETWORK_STARTED, self.notif_network_started), (ZWaveNetwork.SIGNAL_NETWORK_RESETTED, self.notif_network_resetted), (ZWaveNetwork.SIGNAL_NETWORK_READY, self.notif_network_ready), (ZWaveNetwork.SIGNAL_NODE_ADDED, self.notif_node_added), (ZWaveNetwork.SIGNAL_NODE_NAMING, self.notif_node_named), (ZWaveNetwork.SIGNAL_NODE_REMOVED, self.notif_node_removed), (ZWaveNetwork.SIGNAL_VALUE_ADDED, self.notif_value_added), (ZWaveNetwork.SIGNAL_VALUE_CHANGED, self.notif_value_update), (ZWaveNetwork.SIGNAL_VALUE_REMOVED, self.notif_value_removed), (ZWaveNetwork.SIGNAL_CONTROLLER_COMMAND, self.notif_ctrl_message), (ZWaveNetwork.SIGNAL_CONTROLLER_WAITING, self.notif_ctrl_message), ] for notif, func in notif_to_func: dispatcher.connect(self._notif_wrapper(func), notif, weak=False) # dispatcher.connect(self._notif_wrapper_all, All) self.isac_node.add_rpc(self.network_heal) self.isac_node.add_rpc(self.controller_add_node, name='add_node') self.isac_node.add_rpc(self.controller_remove_node, name='remove_node') self.isac_node.add_rpc(self.controller_cancel_command, name='cancel_command')
def _init(self, device, config, timeout): self.network = None self.status = 1 self.timeout = timeout self.device = device self.config = config options = ZWaveOption(self.device, config_path=self.config, user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Debug') options.set_logging(True) options.lock() self.network = ZWaveNetwork(options, autostart=False) dispatcher.connect(louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) self.network.start()
def __init__( self ): device="/dev/ttyUSB0" options = ZWaveOption( "/dev/ttyUSB0", \ config_path=os.path.expanduser("~/.zwave/config/"), \ #user_path='.', \ user_path=os.path.expanduser("~/.zwave/"), \ cmd_line="") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Info') options.set_logging(True) options.lock() print "Initialize Z-Wave network" self.network = ZWaveNetwork(options, log=None) print "Wait for driver" # Waiting for driver for i in range(0,20): if self.network.state>=self.network.STATE_INITIALISED: break else: time.sleep(1.0) if self.network.state<self.network.STATE_INITIALISED: print "Can't initialise driver! Look at the logs in OZW_Log.log" quit(1) print "Wait for network ready" # Waiting for network ready for i in range(0,90): if self.network.state>=self.network.STATE_READY: break else: time.sleep(1.0) if not self.network.is_ready: print "Can't start network! Look at the logs in OZW_Log.log" quit(2)
def start(self): #Create a network object self.network = ZWaveNetwork(self.options, autostart=False) #We connect to the louie dispatcher dispatcher.connect(self.louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self.louie_scene_message, ZWaveNetwork.SIGNAL_SCENE_EVENT) dispatcher.connect(self.loui_ess_q_comp, ZWaveNetwork.SIGNAL_ESSENTIAL_NODE_QUERIES_COMPLETE) dispatcher.connect(self.loui_mess_comp, ZWaveNetwork.SIGNAL_MSG_COMPLETE) self.network.start() #We wait for the network. # print("Waiting for network to become ready : ") for i in range(0,900): if self.network.state>=self.network.STATE_READY: print "Network is ready" break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0)
temp,device = arg.split("=") #Define some manager options options = ZWaveOption(device, \ config_path="../openzwave/config", \ user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Debug') #options.set_save_log_level('Info') options.set_logging(True) options.lock() #Create a network object network = ZWaveNetwork(options, log=None) print "------------------------------------------------------------" print "Waiting for driver : " print "------------------------------------------------------------" for i in range(0,20): if network.state>=network.STATE_INITIALISED: print " done" break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) if network.state<network.STATE_INITIALISED: print "." print "Can't initialise driver! Look at the logs in OZW_Log.log"
print("Hello from network : can't load :(.") def louie_network_ready(network): print("Hello from network : I'm ready : {} nodes were found.".format(network.nodes_count)) print("Hello from network : my controller is : {}".format(network.controller)) dispatcher.connect(louie_node_update, ZWaveNetwork.SIGNAL_NODE) dispatcher.connect(louie_value_update, ZWaveNetwork.SIGNAL_VALUE) def louie_node_update(network, node): print("Hello from node : {}.".format(node)) def louie_value_update(network, node, value): print("Hello from value : {}.".format( value )) #Create a network object network = ZWaveNetwork(options, autostart=False) #We connect to the louie dispatcher dispatcher.connect(louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) network.start() #We wait for the network. print("***** Waiting for network to become ready : ") for i in range(0,90): if network.state>=network.STATE_READY: print("***** Network is ready") break else:
#Define some manager options options = ZWaveOption(device, \ config_path="../openzwave/config", \ user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(True) options.set_save_log_level(log) #options.set_save_log_level('Info') options.set_logging(False) options.lock() print("Memory use : %s Mo" % (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0)) #Create a network object network = ZWaveNetwork(options, log=None) time_started = 0 print "------------------------------------------------------------" print "Waiting for network awaked : " print "------------------------------------------------------------" for i in range(0,300): if network.state>=network.STATE_AWAKED: print(" done") print("Memory use : %s Mo" % (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0)) break else: sys.stdout.write(".") sys.stdout.flush() time_started += 1
print(" --log=Info|Debug") #Define some manager options options = ZWaveOption(device, \ config_path="../openzwave/config", \ user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) #options.set_save_log_level('Debug') options.set_save_log_level(log) options.set_logging(True) options.lock() #Create a network object network = ZWaveNetwork(options, log=None) print("------------------------------------------------------------") print("Try to evaluate memory use ") print("------------------------------------------------------------") print("------------------------------------------------------------") print("Waiting for driver : ") print("------------------------------------------------------------") for i in range(0,20): if network.state>=network.STATE_STARTED: print(" done") break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0)
class ZWaveCommander: def __init__(self, stdscr): self._curAlert = False self._alertStack = list() self._driverInitialized = False self._options = None self._network = None self._listMode = True self._screen = stdscr self._version = '0.1 Beta 1' self._listtop = 0 self._listindex = 0 self._listcount = 0 self._selectedNode = None self._stop = threading.Event() self._keys = { 'A' : 'Add', 'B' : 'About', 'D' : 'Delete', 'R' : 'Refresh', 'S' : 'Setup', '+' : 'Increase', '-' : 'Decrease', '1' : 'On', '0' : 'Off', 'Q' : 'Quit' } #self._network = ZWaveWrapper.getInstance(device=self._config['device'], config=self._config['config'], log=None) self._options = ZWaveOption( \ device="/dev/zwave-aeon-s2", \ config_path="openzwave/config", \ user_path=".", \ cmd_line="") self._options.set_log_file("OZW_Log.log") self._options.set_append_log_file(False) self._options.set_save_log_level('Debug') self._options.set_console_output(False) self._options.set_logging(True) self._options.lock() # TODO: add log level to config # TODO: add log enable/disable to config # TODO: logging - can ozw log be redirected to file? If so, we can add ability to view/tail log FORMAT='%(asctime)s\t%(levelname)s\t%(name)s\t%(message)s' logging.basicConfig(filename='zwaveCommander.log', level=logging.DEBUG, format=FORMAT) self._log = logging.getLogger('ZWaveCommander') self._logbar ='\n%s\n' % ('-'*60) def main(self): '''Main run loop''' self._log.info('%sZWaveCommander Version %s Starting%s', self._logbar, self._version, self._logbar) self._initCurses(self._screen) try: self._startNetwork() self._runLoop() finally: self._shutdown() def _delayloop(self, context, duration, callback): self._log.debug('thread %s sleeping...', context) time.sleep(duration) self._log.debug('timer %s expired, executing callback %s', context, callback) if context == 'alert': self._curAlert = False if self._alertStack: self._alert(self._alertStack.pop()) if callback is not None: callback() def _handleQuit(self): # TODO: exit confirmation dialog self._log.info('Stop requested') self._stop.set() def _handleRefresh(self): if self._selectedNode: self._network.refresh(self._selectedNode) def _handleOn(self): if self._selectedNode: self._network.setNodeOn(self._selectedNode) def _handleOff(self): if self._selectedNode: self._network.setNodeOff(self._selectedNode) def _handleIncrease(self): if self._selectedNode: curLevel = self._selectedNode.level newLevel = curLevel + 10 if newLevel > 99: newLevel = 99 self._network.setNodeLevel(self._selectedNode, newLevel) def _handleDecrease(self): if self._selectedNode: curLevel = self._selectedNode.level newLevel = curLevel - 10 if newLevel < 0: newLevel = 0 self._network.setNodeLevel(self._selectedNode, newLevel) def _setTimer(self, context, duration, callback): newTimer = threading.Thread(None, self._delayloop, 'cb-thread-%s' % context, (context, duration, callback), {}) newTimer.setDaemon(True) newTimer.start() def _alert(self, text): '''perform program alert''' if not self._curAlert: self._curAlert = True curses.flash() self._screen.addstr(self._screensize[0] - 1, 0, ' {0:{width}}'.format(text, width=self._screensize[1] - 2), curses.color_pair(self.COLOR_ERROR)) self._screen.refresh() self._setTimer('alert', 1, self._redrawMenu) else: self._alertStack.append(text) def _layoutScreen(self): # TODO: handle screen resize on curses.KEY_RESIZE in loop (tear down, re-calculate, and re-build) # top 5 lines (fixed): system info (including list header) # bottom line (fixed): menu/status # remaining top half: item list (scrolling) # remaining bottom half: split - left half=static info, right half=detail (scrolling) # item list: 8 columns. All column widths here are padded with 1 char space (except col 0, which is always 1 char) # c0=1 char fixed (select indicator) # c1=4 char fixed (id) # c2=10 char min (name) # c3=10 char min (location) # c4=20 char min (type) # c5=9 char fixed (state) # c6=7 char fixed (batt) # c7=7 char fixed (signal) # last three columns: 23 chars: are optional and can fall off if space requires it (min width 45) # "min" columns expand evenly to fit remaining space self._screen.clear() self._log.debug("Laying out screen") self._colwidths=[1,4,10,10,15,12,8,8] self._colheaders=['','ID','Name','Location','Type','State','Batt','Signal'] self._detailheaders=['Info','Values','Classes','Groups','Events'] self._flexcols=[2,3,4] self._rowheights=[5,5,10,1] self._flexrows=[1,2] self._deviceValueColumns=['id','commandClass','instance','index','type','label','value','units'] self._deviceValueWidths= [10,20,9,6,10,20,10,10] self._sortcolumn = self._colheaders[1] self._detailview = self._detailheaders[0] self._screensize = self._screen.getmaxyx() width = self._screensize[1] height = self._screensize[0] self._log.debug('Screen is %d wide by %d high', width, height) # Update dynamic column widths for device list self._log.debug('Initial column widths are: %s', self._colwidths) cwid = 0 for i in self._colwidths: cwid += i flexwidth = width - cwid if flexwidth > 0: adder = divmod(flexwidth, len(self._flexcols)) for i in self._flexcols: self._colwidths[i] += adder[0] self._colwidths[self._flexcols[-1]] += adder[1] self._log.debug('Adjusted column widths are: %s' ,self._colwidths) # Update dynamic row heights for screen sections self._log.debug('Initial row heights are: %s' , self._rowheights) cht = 0 for i in self._rowheights: cht += i flexheight = height - cht if flexheight > 0: adder = divmod(flexheight, len(self._flexrows)) for i in self._flexrows: self._rowheights[i] += adder[0] self._rowheights[self._flexrows[-1]] += adder[1] self._log.debug('Adjusted row heights are: %s' , self._rowheights) if curses.has_colors(): self._log.debug('Curses initialized: %d colors and %d color pairs available', curses.COLORS, curses.COLOR_PAIRS) else: self._log.debug('Curses initialized, but no colors are available') self._listpad = curses.newpad(256,256) self._detailpads = { 'Info': curses.newpad(self._rowheights[2], self._screensize[1]), 'Values': curses.newpad(128, self._screensize[1]), 'Classes': curses.newpad(128, self._screensize[1]), 'Groups': curses.newpad(self._rowheights[2], self._screensize[1]), 'Events': curses.newpad(256, self._screensize[1]) } self._detailpos = dict() for k in self._detailpads.iterkeys(): self._detailpos[k] = 0 self._detailtop = self._rowheights[0] + self._rowheights[1] + 2 self._detailbottom = self._detailtop + self._rowheights[2] - 3 self._updateColumnHeaders() def _initCurses(self, stdscr): '''Configure ncurses application-specific environment (ncurses has already been initialized)''' curses.curs_set(0) # Re-define color attributes... self.COLOR_NORMAL=1 self.COLOR_HEADER_NORMAL=2 self.COLOR_HEADER_HI=3 self.COLOR_ERROR=4 self.COLOR_CRITICAL=5 self.COLOR_WARN=6 self.COLOR_OK=7 curses.init_pair(self.COLOR_NORMAL, curses.COLOR_WHITE, curses.COLOR_BLACK) # normal (selected row is inverted, disabled/sleep is dim) curses.init_pair(self.COLOR_HEADER_NORMAL, curses.COLOR_BLACK, curses.COLOR_GREEN) # header normal curses.init_pair(self.COLOR_HEADER_HI, curses.COLOR_WHITE, curses.COLOR_CYAN) # header hi curses.init_pair(self.COLOR_ERROR, curses.COLOR_YELLOW, curses.COLOR_RED) # error text curses.init_pair(self.COLOR_CRITICAL, curses.COLOR_RED, curses.COLOR_BLACK) # critical curses.init_pair(self.COLOR_WARN, curses.COLOR_YELLOW, curses.COLOR_BLACK) # warn curses.init_pair(self.COLOR_OK, curses.COLOR_GREEN, curses.COLOR_BLACK) # ok self._layoutScreen() def _handleSetup(self): self._alert('handleSetup not yet implemented') def _checkIfInitialized(self): if not self._driverInitialized: msg = 'Unable to initialize driver - check configuration' self._alert(msg) self._log.warning(msg) self._handleSetup() else: self._log.info('OpenZWave initialized successfully.') def _notifyDriverReady(self, network, controller): self._log.info('OpenZWave Driver is Ready; homeid is %0.8x. %d nodes were found.' % (network.home_id, network.nodes_count)) self._driverInitialized = True self._addDialogText(2,'Driver initialized with homeid %0.8x' % network.home_id) self._addDialogText(3,'Node Count is now %' % network.nodes_count) def _notifyNodeAdded(self, network, node): self._addDialogText(3,'Node Count is now %s'.format(network.nodes_count)) self._updateSystemInfo() def _redrawAll(self): self._clearDialog() self._updateSystemInfo() self._updateDeviceList() self._updateColumnHeaders() self._updateDeviceDetail() def _notifyNetworkReady(self, network, controller): self._log.info('OpenZWave Initialization Complete.') self._alert('OpenZWave Initialization Complete.') self._redrawAll() def _notifyNetworkFailed(self, network): self._log.info('OpenZWave Initialization failed.') self._alert('OpenZWave Initialization failed.') self._redrawAll() def _notifyNodeReady(self, network, node): self._readyNodeCount += 1 self._addDialogText(2, 'OpenZWave is querying associated devices') self._addDialogText(3,'Node %s is now ready' % node.node_id) self._addDialogProgress(5, self._readyNodeCount, network.nodes_count) self._updateDeviceList() def _notifyValueChanged(self, signal, **kw): nodeId = kw['nodeId'] self._log.debug('Got value changed notification for node {0}'.format(nodeId)) # TODO: this is very heavy handed - just update appropriate elements self._updateDeviceList() self._updateDeviceDetail() def _initDialog(self, height, width, buttons=('OK',), caption=None): self._dialogpad = curses.newpad(height, width) self._dialogpad.bkgd(0x94, curses.color_pair(self.COLOR_HEADER_HI)) self._dialogpad.clear() self._dialogpad.box() if caption: lh = (width / 2) - (len(caption) / 2) - 1 self._dialogpad.addstr(0, lh, ' {0} '.format(caption), curses.color_pair(self.COLOR_NORMAL) | curses.A_STANDOUT) if buttons: if len(buttons) > 1: bwid = 0 for bcap in buttons: if len(bcap) > bwid: bwid = len(bcap) cellwid = (width - 4) / len(buttons) lpad = (cellwid - bwid) / 2 - 1 rpad = cellwid - bwid - lpad - 1 self._dialogpad.move(height - 2, 1) else: bwid = len(buttons[0]) lpad = rpad = 1 self._dialogpad.move(height - 2, (width / 2) - (bwid / 2) - 2) for button in buttons: self._dialogpad.addstr('{0:{wlpad}}<{1:^{wbwid}}>{0:{wrpad}}'.format('',button, wlpad=lpad, wbwid=bwid, wrpad=rpad)) dt = (self._screensize[0] / 2) - (height / 2) dl = (self._screensize[1] / 2) - (width / 2) dc = padcoords(sminrow=dt,smincol=dl,smaxrow=dt+height - 1, smaxcol=dl+width - 1) self._dialogcoords = dc self._dialogpad.overlay(self._screen, 0, 0, dc.sminrow, dc.smincol, dc.smaxrow, dc.smaxcol) self._screen.refresh() def _clearDialog(self): del self._dialogpad self._dialogpad = None self._dialogcoords = None self._screen.touchwin() self._screen.refresh() def _updateDialog(self): if self._dialogpad: self._screen.refresh() dc = self._dialogcoords self._dialogpad.refresh(0,0,dc.sminrow, dc.smincol, dc.smaxrow, dc.smaxcol) def _addDialogText(self, row, text, align='^'): if self._dialogpad: self._dialogpad.addstr(row, 1, '{0:{aln}{wid}}'.format(text, aln=align, wid=self._dialogpad.getmaxyx()[1] - 2)) self._updateDialog() def _addDialogProgress(self, row, current, total, showPercent=True, width=None): if self._dialogpad: dc = self._dialogcoords if width is None: width = (dc.smaxcol - dc.smincol) * 2 / 3 pct = float(current) / float(total) filled = int(pct * float(width)) lh = ((dc.smaxcol - dc.smincol) / 2) - (width / 2) self._dialogpad.addch(row, lh - 1, '[', curses.color_pair(self.COLOR_NORMAL) | curses.A_BOLD) self._dialogpad.addch(row, lh + width, ']', curses.color_pair(self.COLOR_NORMAL) | curses.A_BOLD) self._dialogpad.addstr(row, lh, ' '*width, curses.color_pair(self.COLOR_NORMAL)) self._dialogpad.addstr(row, lh, '|'*filled, curses.color_pair(self.COLOR_OK) | curses.A_BOLD) if showPercent: pctstr = '{0:4.0%}'.format(pct) lh = ((dc.smaxcol - dc.smincol) / 2) - (len(pctstr) / 2) self._dialogpad.addstr(row, lh, pctstr, curses.color_pair(self.COLOR_NORMAL) | curses.A_BOLD) self._updateDialog() def _startNetwork(self): dispatcher.connect(self._notifyDriverReady, ZWaveNetwork.SIGNAL_DRIVER_READY) dispatcher.connect(self._notifyNetworkReady, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self._notifyNetworkFailed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self._notifyNodeReady, ZWaveNetwork.SIGNAL_NODE_READY) dispatcher.connect(self._notifyValueChanged, ZWaveNetwork.SIGNAL_VALUE_CHANGED) dispatcher.connect(self._notifyNodeAdded, ZWaveNetwork.SIGNAL_NODE_ADDED) self._initDialog(10,60,['Cancel'],'Progress') self._addDialogText(2,'Initializing OpenZWave') self._log.info('Initializing OpenZWave') self._network = ZWaveNetwork(self._options, log=self._log) #self._network = ZWaveWrapper.getInstance(device=self._config['device'], config=self._config['config'], log=None) self._setTimer('initCheck', 3, self._checkIfInitialized) while not self._stop.isSet() and not self._driverInitialized: time.sleep(0.1) # TODO: handle keys here... cancel/etc def _runLoop(self): while not self._stop.isSet(): key = self._screen.getch() if key == curses.KEY_DOWN: self._switchItem(1) elif key == curses.KEY_UP: self._switchItem(-1) elif key == curses.KEY_LEFT: self._switchTab(-1) elif key == curses.KEY_RIGHT: self._switchTab(1) elif key == 0x09: self._nextMode() elif key is not None: self._handleMnemonic(key) def _handleMnemonic(self, key): for mnemonic, func in self._keys.iteritems(): if key == ord(mnemonic[0].lower()) or key == ord(mnemonic[0].upper()): funcname = '_handle%s' % func try: method = getattr(self, funcname) method() except AttributeError as ex: msg = 'No method named [%s] defined!' % funcname self._log.warn('handleMnemonic: %s', msg) self._log.warn('handleMnemonic Exception Details: %s', str(ex)) self._alert(msg) break def _resetDetailPos(self): for p in self._detailpos.iterkeys(): self._detailpos[p] = 0 def _switchItem(self, delta): if self._listMode: n = self._listindex + delta if n in range(0, self._listcount): self._listindex = n self._updateDeviceList() # TODO: we don't really need to redraw everything when selection changes self._resetDetailPos() self._updateDeviceDetail() else: self._detailpos[self._detailview] += delta self._updateDeviceDetail() def _switchTab(self, delta): if self._listMode: i = self._colheaders.index(self._sortcolumn) i += delta if i > len(self._colheaders) - 1: i = 1 elif i < 1: i = len(self._colheaders) - 1 self._sortcolumn = self._colheaders[i] else: i = self._detailheaders.index(self._detailview) i += delta if i > len(self._detailheaders) - 1: i = 0 elif i < 0: i = len(self._detailheaders) - 1 self._detailview = self._detailheaders[i] self._updateColumnHeaders() self._updateDeviceList() self._updateDeviceDetail() def _nextMode(self): self._listMode = not self._listMode self._updateColumnHeaders() def _shutdown(self): # TODO: handle orderly shutdown pass def _rightPrint(self, row, data, attrs=None): if attrs is None: attrs = curses.color_pair(self.COLOR_NORMAL) self._screen.addstr(row, self._screensize[1] - len(data), data, attrs) def _updateSystemInfo(self): self._screen.addstr(0,1,'%s on %s' % \ (self._network.controller.description, self._network.controller.device), \ curses.color_pair(self.COLOR_NORMAL)) self._screen.addstr(1,1,'Home ID 0x%0.8x' % \ (self._network.self._network.home_id), \ curses.color_pair(self.COLOR_NORMAL)) self._screen.move(2,1) self._screen.addstr('%s Registered Nodes' % \ (self._network.nodes_count), \ curses.color_pair(self.COLOR_NORMAL)) self._screen.addstr(' (%s Sleeping)' % \ (self._network.sleeping_nodes_count), \ curses.color_pair(self.COLOR_NORMAL) | curses.A_DIM) self._rightPrint(0, 'Library' % \ (self._network.controller.library_description)) self._rightPrint(1, 'Python Library Version %s' % \ (self._network.controller.python_library_version)) self._screen.refresh() def _updateColumnHeaders(self): self._screen.move(4,0) for text, wid in zip(self._colheaders, self._colwidths): clr = curses.color_pair(self.COLOR_HEADER_NORMAL) if self._listMode else curses.color_pair(self.COLOR_NORMAL) | curses.A_STANDOUT if text == self._sortcolumn: clr = curses.color_pair(self.COLOR_HEADER_HI) | curses.A_BOLD self._screen.addstr('{0:<{width}}'.format(text, width=wid), clr) self._screen.move(self._rowheights[0] + self._rowheights[1] + 1, 0) clr = curses.color_pair(self.COLOR_HEADER_NORMAL) if not self._listMode else curses.color_pair(self.COLOR_NORMAL) | curses.A_STANDOUT self._screen.addstr('{0:{width}}'.format('', width=self._screensize[1]), clr) self._screen.move(self._rowheights[0] + self._rowheights[1] + 1, 0) for text in self._detailheaders: clr = curses.color_pair(self.COLOR_HEADER_NORMAL) if not self._listMode else curses.color_pair(self.COLOR_NORMAL) | curses.A_STANDOUT if text == self._detailview: clr = curses.color_pair(self.COLOR_HEADER_HI) | curses.A_BOLD wid = len(text) self._screen.addstr(' {0:<{width}} '.format(text, width=wid), clr) def _fixColumn(self, text, width, align='<'): retval = '{0:{aln}{wid}}'.format(text, aln=align, wid=width) if len(retval) > width: retval = retval[:width] return retval def _getListItemColor(self, drawSelected): return curses.color_pair(self.COLOR_NORMAL) | curses.A_STANDOUT if drawSelected \ else curses.color_pair(self.COLOR_NORMAL) def _drawMiniBar(self, value, minValue, maxValue, drawWidth, drawSelected, drawPercent=False, colorLevels=None): clr = self._getListItemColor(drawSelected) pct = float(value) / float(maxValue) dw = drawWidth - 2 filled = int(pct * float(dw)) fillcolor = clr if not drawSelected: fillcolor = curses.color_pair(self.COLOR_OK) if colorLevels: if pct <= colorLevels.error: fillcolor = curses.color_pair(self.COLOR_CRITICAL) elif pct <= colorLevels.warning: fillcolor = curses.color_pair(self.COLOR_WARN) self._listpad.addch('[', clr | curses.A_BOLD) self._listpad.addstr('|' * filled, fillcolor) self._listpad.addstr(' ' * (dw - filled), clr) self._listpad.addch(']', clr | curses.A_BOLD) # TODO: draw percent text if requested def _drawNodeStatus(self, node, drawSelected): clr = self._getListItemColor(drawSelected) if node.is_sleeping: self._listpad.addstr(self._fixColumn('(sleeping)', self._colwidths[5]), clr | curses.A_LOW) elif node.has_command_class(0x76): # lock self._listpad.addstr(self._fixColumn('Locked' if node.is_locked else 'Unlocked', self._colwidths[5]), clr) elif node.has_command_class(0x26): # multi-level switch self._drawMiniBar(node.level, 0, 99, self._colwidths[5], drawSelected) elif node.has_command_class(0x25): # binary switch self._listpad.addstr(self._fixColumn('ON' if node.is_on else 'OFF', self._colwidths[5]), clr) else: self._listpad.addstr(self._fixColumn('OK', self._colwidths[5]), clr) def _drawBatteryStatus(self, node, drawSelected): clr = self._getListItemColor(drawSelected) if node.has_command_class(0x80): self._drawMiniBar(node.batteryLevel, 0, 100, self._colwidths[6], drawSelected, colorLevels=colorlevels(error=0.10,warning=0.40)) else: self._listpad.addstr(self._fixColumn('', self._colwidths[6]), clr) def _drawSignalStrength(self, node, drawSelected): clr = self._getListItemColor(drawSelected) self._listpad.addstr(self._fixColumn('', self._colwidths[7]), clr) def _drawDeviceNodeLine(self, node, drawSelected): clr = self._getListItemColor(drawSelected) self._listpad.addstr(' ', clr) self._listpad.addstr(self._fixColumn(node.id, self._colwidths[1]), clr) self._listpad.addstr(self._fixColumn(node.name, self._colwidths[2]), clr) self._listpad.addstr(self._fixColumn(node.location, self._colwidths[3]), clr) self._listpad.addstr(self._fixColumn(node.productType, self._colwidths[4]), clr) self._drawNodeStatus(node, drawSelected) self._drawBatteryStatus(node, drawSelected) self._drawSignalStrength(node, drawSelected) def _updateDeviceList(self): self._listcount = self._network.nodes_count idx = 0 for node in self._network._nodes.itervalues(): if idx == self._listindex: self._selectedNode = node self._listpad.move(idx,0) self._drawDeviceNodeLine(node, idx == self._listindex) idx += 1 ctop = self._rowheights[0] listheight = self._rowheights[1] if self._listindex - self._listtop > listheight: self._listtop = self._listindex - listheight elif self._listindex < self._listtop: self._listtop = self._listindex self._screen.refresh() self._listpad.refresh(self._listtop, 0, ctop, 0, ctop + listheight, self._screensize[1] - 1) self._updateDialog() def _redrawDetailTab(self, pad): self._screen.refresh() pad.refresh(0, 0, self._detailtop, 0, self._detailbottom, self._screensize[1] - 1) def _updateDetail_Values(self, pad): # Draw column header clr = curses.color_pair(self.COLOR_HEADER_HI) | curses.A_BOLD pad.addstr(0,0,'{0:<{width}}'.format(' ', width=self._screensize[1]), clr) pad.move(0,1) for text, wid in zip(self._deviceValueColumns, self._deviceValueWidths): pad.addstr('{0:<{width}}'.format(text.title(), width=wid), clr) node = self._selectedNode if node and node.values: # Grab all items except for configuration values (they have their own tab) vset = list() for value in node.values.itervalues(): if value.valueData: vset.append(value) # Sort the resulting set: (1) command class, (2) instance, (3) index s = sorted(sorted(sorted(vset, key=lambda value: value.getValue('index')), key=lambda value: value.getValue('instance')), key=lambda value: value.getValue('commandClass')) if self._detailpos[self._detailview] >= len(s): self._detailpos[self._detailview]=len(s)-1 i = 0 for value in s: vdic = value.valueData pad.move(i+1,0) # TODO: reset detail position on parent item change drawSelected = self._detailpos['Values'] == i clr = self._getListItemColor(drawSelected) pad.addstr(' ' * self._screensize[1], clr) pad.move(i+1,1) i += 1 for key, wid in zip(self._deviceValueColumns, self._deviceValueWidths): clr = self._getListItemColor(drawSelected) text = value.getValue(key) # strip 'COMMAND_CLASS_' prefix to save some space if key == 'commandClass' and text.startswith('COMMAND_CLASS_'): text = text[14:] # TODO: value decorators (checkbox for Booleans, edit box for others) # decimal: format to 2 places # bool as checkbox # byte as minibar if editable # ints need to be directly edited... # buttons... ? # Draw editable items differently if key == 'value' and not vdic['readOnly'] and drawSelected: clr = curses.color_pair(self.COLOR_ERROR) pad.addstr(self._fixColumn(text, wid), clr) def _updateDetail_Info(self, pad): node = self._selectedNode if node: #baudRate, basic, generic, specific, version, security self._deviceInfoColumns=['id','name','location','capabilities','neighbors','manufacturer','product','productType'] if self._detailpos[self._detailview] >= len(self._deviceInfoColumns): self._detailpos[self._detailview]=len(self._deviceInfoColumns)-1 editableColumns=['name','location','manufacturer','product'] i = maxwid = 0 for name in self._deviceInfoColumns: maxwid = len(name) if len(name) > maxwid else maxwid colwidth = maxwid + 2 clr = self._getListItemColor(False) clr_rw = curses.color_pair(self.COLOR_ERROR) clr_ro = self._getListItemColor(True) clr_col = curses.color_pair(self.COLOR_OK) # TODO: If editable, should be textpad for column in self._deviceInfoColumns: val = str(getattr(node, column)) pad.move(i + 1, 1) pad.addstr('{0:>{width}}'.format(column.title() + ':', width=colwidth), clr_col) selected = i == self._detailpos[self._detailview] thisclr = clr if selected: thisclr = clr_rw if column in editableColumns else clr_ro i += 1 pad.addstr(' ') pad.addstr('{0:<{width}}'.format(val, width=30), thisclr) def _updateDetail_Classes(self, pad): clr = curses.color_pair(self.COLOR_HEADER_HI) | curses.A_BOLD pad.addstr(0,0,'{0:<{width}}'.format(' CommandClass', width=self._screensize[1]), clr) node = self._selectedNode if node: if self._detailpos[self._detailview] >= len(node.commandClasses): self._detailpos[self._detailview]=len(node.commandClasses)-1 i = 0 for cc in node.commandClasses: pad.addstr(i + 1, 0, ' {0:<{width}}'.format(self._network.getCommandClassName(cc), width=30), self._getListItemColor(i == self._detailpos[self._detailview])) i += 1 def _updateDetail_Groups(self, pad): pad.addstr(3,3,'Group view not yet implemented') # groups tab: # index label maxMembers members # 1 my group 4 1, 2, 4 # Members column is editable - enter comma-separated list? def _updateDetail_Events(self, pad): pad.addstr(3,3,'Event view not yet implemented') # event detail tab: # timestamp commandClass notificationType def _updateDeviceDetail(self): # TODO: detail needs to be scrollable, but to accomplish that a couple of changes need to be made. First, the detail header band needs to be moved into a static shared section (above the detail pad); second, a new dict of 'top' positions needs to be created; finally, positioning code needs to be written to correctly offset the pad. pad = self._detailpads[self._detailview] pad.clear() if self._detailpos[self._detailview] < 0: self._detailpos[self._detailview]=0 funcname = '_updateDetail_{0}'.format(self._detailview) try: method = getattr(self, funcname) method(pad) except AttributeError as ex: msg = 'No method named [%s] defined!' % funcname self._log.warn('_updateDeviceDetail: %s', msg) self._log.warn('_updateDeviceDetail Exception Details: %s', str(ex)) self._alert(msg) self._redrawDetailTab(pad) def _updateMenu(self): menurow = self._screensize[0] - 1 self._screen.addstr(menurow, 0, ' ' * (self._screensize[1] - 1), curses.color_pair(self.COLOR_HEADER_NORMAL)) self._screen.move(menurow,4) for mnemonic, text in self._keys.iteritems(): self._screen.addstr(' {0} '.format(mnemonic), curses.color_pair(self.COLOR_NORMAL) | curses.A_BOLD) self._screen.addstr('{0}'.format(text), curses.color_pair(self.COLOR_HEADER_NORMAL)) def _redrawMenu(self): self._updateMenu() self._screen.refresh()
class zwave(object): #Define some manager options options = ZWaveOption(device, \ config_path=constants.zwpath, \ user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level(log) options.set_logging(True) options.lock() def louie_network_started(self, network): dicti = {'Log':'Z-Wave Network started'} # mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort)) mqtt_publish.mqtt_pub('Inputs/Satellite/' + constants.name + '/Log',dicti) print("Hello from network : I'm started : homeid {:08x} - {} nodes were found.".format(network.home_id, network.nodes_count)) def louie_network_failed(self, network): pass print("Hello from network : can't load :(.") def louie_network_ready(self, network): dicti = {'Log':'Z-Wave Network up running'} # mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort)) mqtt_publish.mqtt_pub('Inputs/Satellite/' + constants.name + '/Log',dicti) dispatcher.connect(self.louie_node_update, ZWaveNetwork.SIGNAL_NODE) dispatcher.connect(self.louie_scene_message, ZWaveNetwork.SIGNAL_NODE_EVENT) dispatcher.connect(self.louie_value_update, ZWaveNetwork.SIGNAL_VALUE) print('Dispatcher connected') def louie_scene_message(self, *args, **kwargs): print('scene happening') for count, thing in enumerate(args): print( '{0}. {1}'.format(count, thing)) for name, value in kwargs.items(): print( '{0} = {1}'.format(name, value)) def loui_ess_q_comp(self): pass # print('nodes ess queried') def loui_mess_comp(self): print('mess complete') def louie_node_update(self, network, node): pass print("Hello from node : {}.".format(node)) def louie_value_update(self, network, node, value): print "value changed" try: # print zw_config.inputs[node.home_id][value.value_id], int(value.data) dicti = {'Value': str(int(value.data))} dicti['Name'] = 'ZWave.' + str(node.home_id) + '.' + str(value.value_id) #print dicti # mySocket.sendto(str(dicti) ,(constants.server1,constants.broadPort)) mqtt_publish.mqtt_pub('Inputs/Satellite/' + constants.name + '/ZWave/' + str(int(node.home_id)) +'/'+ str(int(value.value_id)) ,dicti) except: print 'not understood', node, value.value_id, value.data # print("Hello from value : {}.".format( value )) # home_id: [0xeefad666] id: [72057594093060096] parent_id: [3] label: [Switch] data: [False]. # home_id: [0xeefad666] id: [72057594093273218] parent_id: [3] label: [Power] data: [0.0]. # home_id: [0xeefad666] id: [144115188131201026] parent_id: [3] label: [Energy] data: [0.00999999977648] # value.label = switch def __init__(self): pass def start(self): #Create a network object self.network = ZWaveNetwork(self.options, autostart=False) #We connect to the louie dispatcher dispatcher.connect(self.louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(self.louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) dispatcher.connect(self.louie_scene_message, ZWaveNetwork.SIGNAL_SCENE_EVENT) dispatcher.connect(self.loui_ess_q_comp, ZWaveNetwork.SIGNAL_ESSENTIAL_NODE_QUERIES_COMPLETE) dispatcher.connect(self.loui_mess_comp, ZWaveNetwork.SIGNAL_MSG_COMPLETE) self.network.start() #We wait for the network. # print("Waiting for network to become ready : ") for i in range(0,900): if self.network.state>=self.network.STATE_READY: print "Network is ready" break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) #time.sleep(5.0) #We update the name of the controller #print("Update controller name") #network.controller.node.name = "Hello name" #time.sleep(5.0) #We update the location of the controller #print("Update controller location") #network.controller.node.location = "Hello location" # for node in self.network.nodes: # for val in self.network.nodes[node].get_switches() : # print("Switch : {}".format(self.network.nodes[node])) # print("Switch1: {}".format(val)) # 72057594093060096 # 144115188130988032 # network.nodes[node].set_switch(val,True) #We only activate the first switch #exit # for node in self.network.nodes: # for val in self.network.nodes[node].get_dimmers() : # print("Dimmer : {}".format(self.network.nodes[node])) # print("Switch1: {}".format(val)) # 72057594093076481 # 144115188131004513 # 144115188131004417 # 72057594093076577 # network.nodes[node].set_dimmer(val,80) #We only activate the first dimmer #exit def end_network(self): self.network.stop() def _set_switch(self,node_id , switch, wert): if wert == 'Toggle': cur_val = self.network.nodes[node_id].get_switch_state(switch) self.network.nodes[node_id].set_switch(switch, not cur_val) else: if eval(wert) > 0: self.network.nodes[node_id].set_switch(switch, True) else: self.network.nodes[node_id].set_switch(switch, bool(eval(wert))) return True def _set_dimmer(self,node_id , dimmer, wert): if wert == 'Toggle': cur_val = self.network.nodes[node_id].get_dimmer_level(dimmer) if cur_val == 0: self.network.nodes[node_id].set_dimmer(dimmer, 50) else: self.network.nodes[node_id].set_dimmer(dimmer, 0) else: self.network.nodes[node_id].set_dimmer(dimmer, eval(wert)) return True def set_device(self, data_ev): # TODO do threaded with stop criteria if data_ev.get('Device') in zw_config.switches: print data_ev return self._set_switch(zw_config.switches[data_ev['Device']][0],zw_config.switches[data_ev['Device']][1],data_ev['Value']) if data_ev.get('Device') in zw_config.dimmer: print data_ev return self._set_dimmer(zw_config.dimmer[data_ev['Device']][0],zw_config.dimmer[data_ev['Device']][1],data_ev['Value'])
class ZWaveControlPlugin(Plugin): @staticmethod def get_dependencies(): return [] def __init__(self, object_group, config): Plugin.__init__(self, config=config, object_group=object_group, plugin_name=PLUGIN_NAME) # Get parameters from the config file if not self.is_enabled(): return # Initialize zwave library # Options try: opts = ZWaveOption(device="/dev/ttyUSB0", config_path="/home/mlamonta/git/python-openzwave/openzwave/config/", user_path="logs") opts.set_log_file("./logs/zwave.log") opts.set_save_log_level("Alert") opts.set_append_log_file(False) opts.set_console_output(False) opts.set_logging(True) opts.lock() except ZWaveException as e: self.logger.error(str(e)) return # Network self.net = ZWaveNetwork(opts) self.logger.info("------------------------------------------------------------") self.logger.info("Waiting for network awake : ") self.logger.info("------------------------------------------------------------") for i in range(0, 300): if self.net.state >= self.net.STATE_AWAKED: self.logger.info("done") break else: time.sleep(1.0) if self.net.state < self.net.STATE_AWAKED: self.logger.warning("Network is not awake") return self.logger.info("------------------------------------------------------------") for node in self.net.nodes: self.logger.info("%s - %s / %s" % (self.net.nodes[node].node_id, self.net.nodes[node].manufacturer_name, self.net.nodes[node].product_name) ) self._initialized = True @staticmethod def get_template_config(config): config.add_section(PLUGIN_NAME) config.set(PLUGIN_NAME, "enabled", "true") def stop(self): if self.is_initialized(): self.net.stop() @staticmethod def get_dimmer_code(uid, name, current_value): dimmer_html = """ <div class="col-md-5"> <h2>Dimmer</h2> <div class="input-group input-group-lg"> <input type="text" class="form-control" name="%s" value="%s"> <!-- DIMMER NAME, VALUE --> <div class="input-group-btn"> <button name="%s" type="button" class="btn btn-primary" onclick="updateZWave('%s')">Submit</button> </div> </div> <script> $("input[name='%s']").TouchSpin({ min: 0, max: 100, step: 1, decimals: 0, boostat: 5, maxboostedstep: 10, prefix: "Set:", postfix: '%%' }); </script> </div> """ % (str(uid), current_value, str(uid) + "_btn", str(uid), str(uid) ) return dimmer_html def get_html(self): html = "" if self.is_initialized(): html = '<div id="zwave" class="jumbotron">' for node in self.net.nodes: node_html = "" switches = self.net.nodes[node].get_switches() for switch in switches: node_html += "<h3>" + str(switches[switch].label) + " " + str(switches[switch].data) + "</h3>" dimmers = self.net.nodes[node].get_dimmers() for dimmer in dimmers: node_html += ZWaveControlPlugin.get_dimmer_code(dimmer, "Dimmer: " + str(dimmer), str(dimmers[dimmer].data)) html += """ <div class="row"> <div class="col-md-12"> <h2>%d: %s - %s</h2> %s </div> </div> """ % ( self.net.nodes[node].node_id, self.net.nodes[node].manufacturer_name, self.net.nodes[node].product_name, node_html ) html += "</div>" return html def parse_zwave_command_message(self, msg): try: if not self.is_initialized(): self.logger.warning("Error zwave message while uninitialized") return if len(msg.split(',')) != 3: self.logger.warning("Error parsing zwave message") return self.logger.debug("Got message: " + msg) dev = msg.split(',')[1] val = int(msg.split(',')[2]) # Find the right device and set its value for node in self.net.nodes: switches = self.net.nodes[node].get_switches() for switch in switches: self.logger.debug("checking switch: " + str(switch)) if str(switch) == dev: switches[switch].data = switches[switch].check_data(val) self.logger.debug("match") return dimmers = self.net.nodes[node].get_dimmers() for dimmer in dimmers: self.logger.debug("checking dimmer: " + str(dimmer) ) if str(dimmer) == dev: dimmers[dimmer].data = dimmers[dimmer].check_data(val) self.logger.debug("match") return self.logger.warning("device: " + dev + " not found") except Exception as e: self.logger.error("Exception in parse_zwave_command_message: " + e.message) def get_javascript(self): jscript = "" if self.is_initialized(): jscript = """ function updateZWave(device) { var new_value = $("input[name='"+device+"']").val() $.get("cgi-bin/web_control.py?set_zwave="+new_value+"&device="+device, function (result) { if (result.trim() == "OK") { $("button[name='"+device+"_btn']").toggleClass('btn-primary'); $("button[name='"+device+"_btn']").toggleClass('btn-success'); setTimeout(function() { $("button[name='"+device+"_btn']").toggleClass('btn-success'); $("button[name='"+device+"_btn']").toggleClass('btn-primary'); }, 5000); } else { $("button[name='"+device+"_btn']").toggleClass('btn-primary'); $("button[name='"+device+"_btn']").toggleClass('btn-danger'); alert(result); setTimeout(function() { $("button[name='"+device+"_btn']").toggleClass('btn-danger'); $("button[name='"+device+"_btn']").toggleClass('btn-primary'); }, 5000); } }); } """ return jscript
class Open_zwave(HAInterface): VERSION = '0.0.2' awake = False ready = False nodesdisplayed = False def louie_network_ready(network): self._logger.info(">>>>>>> Hello from network : I'm ready : %d nodes were found." % self._network.nodes_count) self._logger.info(">>>>>>> Hello from network : my controller is : %s" % self._network.controller) dispatcher.connect(self.louie_node_update, ZWaveNetwork.SIGNAL_NODE) dispatcher.connect(self.louie_value_update, ZWaveNetwork.SIGNAL_VALUE) def louie_node_update(network, node): self._logger.info('>>>>>>> Hello from node : %s.' % node) def louie_value_update(network, node, value): self._logger.info('>>>>>>> Hello from value : %s.' % value) def __init__(self, *args, **kwargs): self._serialDevicePath = kwargs.get('serialDevicePath', None) self._options = ZWaveOption(self._serialDevicePath, \ config_path="/usr/local/etc/openzwave/", \ user_path=".", cmd_line="") self._options.set_log_file("OZW_Log.log") self._options.set_append_log_file(False) self._options.set_console_output(False) #self._options.set_save_log_level(log) self._options.set_save_log_level('Info') self._options.set_logging(True) self._options.set_notify_transactions(True) self._options.lock() self._network = ZWaveNetwork(self._options, log=None,autostart=False) dispatcher.connect(self.louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) self._network.start() super(Open_zwave, self).__init__(self, *args, **kwargs) def _printNetwork(self, node): print print "------------------------------------------------------" print "%s - Name : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].name) print "%s - Manufacturer name / id : %s / %s" % ( self._network.nodes[node].node_id, self._network.nodes[node].manufacturer_name, self._network.nodes[node].manufacturer_id) print "%s - Product name / id / type : %s / %s / %s" % ( self._network.nodes[node].node_id, self._network.nodes[node].product_name, self._network.nodes[node].product_id, self._network.nodes[node].product_type) print "%s - Version : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].version) print "%s - Command classes : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].command_classes_as_string) print "%s - Capabilities : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].capabilities) print "%s - Neighbors : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].neighbors) print "%s - Can sleep : %s" % (self._network.nodes[node].node_id, self._network.nodes[node].can_wake_up()) def _init(self, *args, **kwargs): super(Open_zwave, self)._init(self, *args, **kwargs) def _readInterface(self, lastPacketHash): if (self._network.state >= self._network.STATE_AWAKED and not self.awake): self.awake = True self._logger.info("Network Awaked") if (self._network.state >= self._network.STATE_READY and not self.ready): self.ready = True self._logger.info("Network Ready") self._logger.info("********************************* NETWORK READY ************************************") if not self.awake: time.sleep(1.0) self._logger.debug("Not awaked") return if self.awake and not self.ready: time.sleep(1.0) self._logger.debug("Not ready") return if not self.nodesdisplayed and self.ready: for node in self._network.nodes: self._printNetwork(node) self.nodesdisplayed = True time.sleep(1) def version(self): self._logger.info("Open_zwave Pytomation Driver version " + self.VERSION) self._logger.info("Use openzwave library : %s" % self._network.controller.ozw_library_version) self._logger.info("Use python library : %s" % self._network.controller.python_library_version) self._logger.info("Use ZWave library : %s" % self._network.controller.library_description) def on(self, address): node = int(address) for val in self._network.nodes[node].get_switches() : self._logger.info("Activate switch") self._network.nodes[node].set_switch(val,True) for val in self._network.nodes[node].get_dimmers() : self._logger.info("Activate dimmer : %s" % self._network.nodes[node]) self._network.nodes[node].set_dimmer(val,99) def off(self, address): node = int(address) for val in self._network.nodes[node].get_switches() : self._logger.info("Activate switch") self._network.nodes[node].set_switch(val,False) for val in self._network.nodes[node].get_dimmers() : self._logger.info("Activate dimmer : %s" % self._network.nodes[node]) self._network.nodes[node].set_dimmer(val,0) def status(self, address): node = int(address) for val in self._network.nodes[node].get_dimmers() : level = self._network.nodes[nodeid].get_dimmer_level(val)
class Network(object): _instance = None def _init(self, device, config, timeout): self.network = None self.status = 1 self.timeout = timeout self.device = device self.config = config options = ZWaveOption(self.device, config_path=self.config, user_path=".", cmd_line="") options.set_log_file("OZW_Log.log") options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level('Debug') options.set_logging(True) options.lock() self.network = ZWaveNetwork(options, autostart=False) dispatcher.connect(louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) dispatcher.connect(louie_network_ready, ZWaveNetwork.SIGNAL_NETWORK_READY) self.network.start() def __new__(class_, device=None, config=None, timeout=None): if not isinstance(class_._instance, class_): if not device: return None class_._instance = object.__new__(class_) class_._instance._init(device, config, timeout) return class_._instance def __del__(self): self.network.stop() def __iter__(self): return self def next(self): self.timeout -= 1 if self.timeout == 0: self.status = 1 raise StopIteration if self.network.state >= self.network.STATE_READY: self.status = 0 raise StopIteration return self.timeout def get_timout(self): return self.timeout def get_status(self): return self.status def stop(self): self.network.stop() def get_state(self): return self.network.state def is_stopped(self): return self.network.state == self.network.STATE_STOPPED def is_running(self): return self.network.state == self.network.STATE_READY
class ZStickInterface(object): def __init__(self): self.sensor_events = [] self.device = "/dev/ttyACM0" config_path = "plugins/python-openzwave/openzwave/config" user_path = "plugins/python-openzwave/config" # If using older Z-sticks, use the below device: # self.device = "/dev/ttyUSB0" # Change config paths where appropriate self.options = ZWaveOption(self.device, config_path=config_path, user_path=user_path, cmd_line="") # Turn off ozw console output self.options.set_console_output(False) self.options.set_save_log_level("Info") self.options.set_logging(False) self.options.lock() self.manager = libopenzwave.PyManager() self.manager.create() self.manager.addWatcher(self.event_callback) self.manager.addDriver(self.device) print("Starting Z-Wave Network...") self.network = ZWaveNetwork(self.options, log=None) # Wait for network to start while not self.network.state >= self.network.STATE_AWAKED: time.sleep(1) print("Z-Wave Network Started") def toggle_switch(self, node_id): try: in_work_node = self.network.nodes[node_id] switch_val = in_work_node.get_switches().keys()[0] if in_work_node.get_switch_state(switch_val): in_work_node.set_switch(switch_val, False) else: in_work_node.set_switch(switch_val, True) except: print("Invalid node id") def switch(self, node_id, state, function): try: in_work_node = self.network.nodes[node_id] if function == "dimmer": switch_val = in_work_node.get_dimmers().keys()[0] if state == "False": in_work_node.set_dimmer(switch_val, 0) elif state == "True": in_work_node.set_dimmer(switch_val, 99) else: in_work_node.set_dimmer(switch_val, int(state)) elif function == "switch": switch_val = in_work_node.get_switches().keys()[0] if state == "False": in_work_node.set_switch(switch_val, False) else: in_work_node.set_switch(switch_val, True) except: print("Invalid node id") def event_callback(self, args): if args["notificationType"] in ("ValueAdded", "ValueChanged"): cmd_class = args["valueId"]["commandClass"] if cmd_class == "COMMAND_CLASS_SENSOR_BINARY": node_id = args["valueId"]["nodeId"] state = args["valueId"]["value"] data = {"node_id": node_id, "state": state} self.sensor_events.append(data) def get_sensor_events(self): last_events = self.sensor_events self.sensor_events = [] return last_events def stop_network(self): self.network.stop()
class ZWDeviceController(IOTDeviceController): def louie_network_started(network): print ( "Hello from network : I'm started : homeid %0.8x - %d nodes were found." % (network.home_id, network.nodes_count) ) def louie_network_failed(network): print ("Hello from network : can't load :(.") def louie_network_ready(network): print ("Hello from network : I'm ready : %d nodes were found." % network.nodes_count) print ("Hello from network : my controller is : %s" % network.controller) dispatcher.connect(louie_node_update, ZWaveNetwork.SIGNAL_NODE) dispatcher.connect(louie_value_update, ZWaveNetwork.SIGNAL_VALUE) def louie_node_update(network, node): print ("Hello from node : %s." % node) def louie_value_update(network, node, value): print ("Hello from value : %s." % value) def __init__(self, name, location, nodefilename="/opt/seciot/nodenames.json"): IOTDeviceController.__init__(self, name) # Restore node stuff nodefile = open(nodefilename, "r") nodejson = nodefile.read() self.node_dict = json.loads(nodejson) # Init options device = "/dev/ttyACM0" sniff = 300.0 options = ZWaveOption(device, config_path="/opt/openzwave/config", user_path=".", cmd_line="") options.set_logging(False) options.set_console_output(False) options.lock() # Create a network object self.network = ZWaveNetwork(options, autostart=False) self.network.set_poll_interval(10, True) # We connect to the louie dispatcher dispatcher.connect(self.louie_network_started, ZWaveNetwork.SIGNAL_NETWORK_STARTED) dispatcher.connect(self.louie_network_failed, ZWaveNetwork.SIGNAL_NETWORK_FAILED) self.network.start() # We wait for the network. print "***** Waiting for network to become ready : " for i in range(0, 300): if self.network.state >= self.network.STATE_READY: print "***** Network is ready" break else: sys.stdout.write(".") sys.stdout.flush() time.sleep(1.0) # We update the name of the controller self.network.controller.node.name = name self.network.controller.node.location = location def export(self): # list of devices # each device has zwavename, friendly name, device type, statepool, currentstates (timestamped) # return self.network.nodes return self.node_dict.keys() def readState(self, node): print "read", self.node_dict print "read", node if type(node) in [str, unicode]: nodenum = self.node_dict[node] else: print type(node) nodenum = node mynode = self.network.nodes[nodenum] state = None for switch in mynode.get_switches(): state = mynode.get_switch_state(switch) print node print state return state def setState(self, node, state): print "set", self.node_dict print "set", node if type(node) in [str, unicode]: nodenum = self.node_dict[node] else: nodenum = node if state in [1, "1", u"1", True]: boolstate = True elif state in [0, "0", u"0", False]: boolstate = False else: print state print type(state) raise error("bad") print state for switch in self.network.nodes[nodenum].get_switches(): self.network.nodes[nodenum].set_switch(switch, boolstate)