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 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 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 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 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)
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
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 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 __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 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 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()
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 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 _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 _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 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)
def log_level(self): self.logger.info("Performing log level entries") options = ZWaveOption( device, config_path="/home/riaps/python-openzwave/openzwave/config", user_path=".", cmd_line="") options.set_log_file("OZW.log") options.set_append_log_file(False) options.set_save_log_level("Info") options.set_console_output(False) options.set_logging(True) options.lock() self.ZWaveOption = options self.network = ZWaveNetwork(options, log=None, autostart=False) self.logger.info("log level entries done")
def _init_openzwave(self, zwave_device, zwave_config_path, zwave_user_path): """Initialise the OpenZWave client, leaving it ready to start.""" # Configure OpenZWave options = ZWaveOption(zwave_device, config_path=zwave_config_path, user_path=zwave_user_path, cmd_line="") options.set_log_file(os.path.join(zwave_user_path, "zwave.log")) options.set_append_log_file(True) options.set_console_output(True) options.set_save_log_level("Warning") options.set_logging(True) options.lock() self._ozw_network = ZWaveNetwork(options, autostart=False)
def init(): log.info("initializing...") global _network #Define some manager options options = ZWaveOption(config.ZWAVE_DEVICE, config_path=config.OPENZWAVE_CONFIG_FILE, user_path=".", cmd_line="") options.set_log_file(config.OPENZWAVE_LOG_FILE) options.set_append_log_file(False) options.set_console_output(False) options.set_save_log_level(config.OPENZWAVE_LOG_LEVEL) #options.set_save_log_level('Info') options.set_logging(True) options.lock() #Create a network object _network = ZWaveNetwork(options)
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 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 main(): term = Terminal() options = ZWaveOption(device='/dev/ttyACM0') options.set_log_file('test.log') options.set_append_log_file(True) options.set_console_output(False) options.set_logging(True) options.lock() network = ZWaveNetwork(options) event_handler = EventHandler() start_time = dt.utcnow() composer: Composer with ComposerContext(term) as composer: sb = StatusBuffer(term) help_dialog = HelpDialog(term) composer.add_widget(sb) composer.add_widget(help_dialog.dialog) sb.set_buffer_behavior(StatusBuffer.BEHAVIOR_TOP) controller = BufferController(sb, network) event_handler.register(controller) print("> {}".format(controller.handled_buffer_events())) sb.set_trigger(controller.handled_buffer_events(), controller.handle_buffer_event) starting_spinner = 0 available_since = None last_known_state = None while True: ch = term.inkey(timeout=0.25) if ch: composer.handle_inkey(ch) controller.update() composer.refresh() time.sleep(0.25)
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