def __init__(self, name, stop_cb = None, is_manager = False, parser = None, daemonize = True, log_prefix = "xplplugin_", test = False, nohub = False, source = None): ''' Create XplPlugin instance, which defines system handlers @param nohub : if set the hub discovery will be disabled @param source : overwrite the source value (client-device.instance) ''' Plugin.__init__(self, name, stop_cb = stop_cb, is_manager = is_manager, parser = parser, daemonize = daemonize, log_prefix = log_prefix, test = test) ### start xpl dedicated part self.log.info(u"Start of the xPL init") # start the xPL manager if 'broadcast' in self.config: broadcast = self.config['broadcast'] else: broadcast = "255.255.255.255" if 'bind_interface' in self.config: self.myxpl = Manager(self.config['bind_interface'], broadcast = broadcast, plugin = self, nohub = nohub, source = source) else: self.myxpl = Manager(broadcast = broadcast, plugin = self, nohub = nohub) # hbeat not yet called (will be called by the ready() function by a developper plugin) self.enable_hbeat_called = False # define the source (in can be used in some plugins) if source == None: self.source = "{0}-{1}.{2}".format(DMG_VENDOR_ID, self.get_plugin_name(), self.get_sanitized_hostname()) # in case we overwrite the source : self.source = source self.log.info(u"End of the xPL init")
def __init__(self, name, stop_cb = None, is_manager = False, parser = None, daemonize = True, log_prefix = "xplplugin_", test = False, nohub = False): ''' Create XplPlugin instance, which defines system handlers @param nohub : if set the hub discovery will be disabled ''' Plugin.__init__(self, name, stop_cb = stop_cb, is_manager = is_manager, parser = parser, daemonize = daemonize, log_prefix = log_prefix, test = test) ### start xpl dedicated part self.log.info(u"Start of the xPL init") # start the xPL manager if 'broadcast' in self.config: broadcast = self.config['broadcast'] else: broadcast = "255.255.255.255" if 'bind_interface' in self.config: self.myxpl = Manager(self.config['bind_interface'], broadcast = broadcast, plugin = self, nohub = nohub) else: self.myxpl = Manager(broadcast = broadcast, plugin = self, nohub = nohub) # hbeat not yet called (will be called by the ready() function by a developper plugin) self.enable_hbeat_called = False self.log.info(u"End of the xPL init")
def __init__(self): """ Create background RFPlayer manager """ Plugin.__init__(self, name='rfplayer') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return self.managerRFP = None self._ctrlsHBeat = None # Get some config value try: self.pathData = self.get_data_files_directory() except: self.log.warning('Data directory access error : {0}'.format( traceback.format_exc())) self.pathData = "{0}/{1}/{2}_{3}/data/".format( self.libraries_directory, PACKAGES_DIR, self._type, self._name) # Initialize plugin Manager try: self.managerRFP = RFPManager(self, self.send_sensor) except Exception as e: raise self.log.error('Error on creating RFPManager : {0}'.format(e)) self.force_leave() return self.register_cb_update_devices(self.managerRFP.refreshDevices) self.add_mq_sub('device.update') self.add_mq_sub('device.new') self.log.info('****** Init RFPlayer plugin manager completed ******') self.ready()
def __init__(self, name, stop_cb=None, is_manager=False, parser=None, daemonize=True, log_prefix="interface_", log_on_stdout=True, test=False, source=None): ''' Create Interface instance, which defines system handlers @param source : overwrite the source value (client-device.instance) ''' Plugin.__init__(self, name, type="interface", stop_cb=stop_cb, is_manager=is_manager, parser=parser, daemonize=daemonize, log_prefix=log_prefix, log_on_stdout=log_on_stdout, test=test) self.log.info(u"Start of the interface init") # define the source (in can be used in some plugins) if source == None: self.source = "{0}-{1}.{2}".format(INTERFACE_VENDOR_ID, self.get_plugin_name(), self.get_sanitized_hostname()) # in case we overwrite the source : else: self.source = source ### MQ self._mq_name = self.source #self.zmq = zmq.Context() self.mq_pub = MQPub(self.zmq, self._mq_name) # subscribe the MQ for interfaces inputs MQAsyncSub.__init__(self, self.zmq, self._name, ['interface.output']) ### Context # set the context # All elements that may be added in the request sent over MQ # * media (irc, audio, sms, ...) # * text (from voice recognition) # * location (the input element location : this is configured on the input element : kitchen, garden, bedroom, ...) # * identity (from face recognition) # * mood (from kinect or anything else) # * sex (from voice recognition and post processing on the voice) self.butler_context = { "media": None, "location": None, "identity": None, "mood": None, "sex": None } self.log.info(u"End of the interface init")
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='body') # check if the plugin is configured. If not, this will stop the plugin and log an error # if not self.check_configured(): # return # get the devices list self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device: self.commands = self.get_commands(self.devices) self.sensors = self.get_sensors(self.devices) self.log.info(u"==> commands: %s" % format(self.commands)) self.log.info(u"==> sensors: %s" % format(self.sensors)) # INFO ==> sensors: {66: {u'set_weight': 159}} # {'device id': {'sensor name': 'sensor id'}} # for each device ... self.body_namelist = {} for a_device in self.devices: # global device parameters device_name = a_device["name"] # Ex.: "john" device_id = a_device["id"] # Ex.: "128" device_typeid = a_device["device_type_id"] # Ex.: "body.body self.log.info(u"==> Device '%s' (id:%s / %s), Sensor: '%s'" % (device_name, device_id, device_typeid, self.sensors[device_id])) # INFO ==> Device 'VDevice Binary 1' (id:112 / vdevice.info_binary), Sensor: '{u'get_info_binary': 216}' # INFO ==> Device 'VDevice Number 1' (id:113 / vdevice.info_number), Sensor: '{u'get_info_number': 217}' # INFO ==> Device 'VDevice String 1' (id:114 / vdevice.info_string), Sensor: '{u'get_info_string': 218}' self.body_namelist[device_id] = device_name self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='yi') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # get the config self.ffserver_ip = self.get_config("ffserver_ip") self.ffserver_port = int(self.get_config("ffserver_port")) self.motion_files_history = self.get_config("motion_files_history") # get the devices list self.devices = self.get_device_list(quit_if_no_device = True) # send sensor values self.send_sensor_yi_values() # generate the ffserver.conf file ffserver_file = os.path.join(self.get_data_files_directory(), "ffserver.conf") self.yi = Yi(self.log, self.get_stop(), ffserver_file, self.ffserver_ip, self.ffserver_port, self.devices, self.get_parameter) self.yi.generate_ffserver_config() # start checking for motion (each minute) on all yi threads = {} for a_device in self.devices: ip = self.get_parameter(a_device, "ip") do_download = self.get_parameter(a_device, "download_motion_files") sensor_motion_id = a_device['sensors']['motion']['id'] sensor_motion_file_id = a_device['sensors']['motion_file']['id'] thr_name = "dev_{0}".format(a_device['id']) threads[thr_name] = threading.Thread(None, self.yi.check_motion, thr_name, (ip, sensor_motion_id, sensor_motion_file_id, self.send_sensor_value, self.get_publish_files_directory, do_download), {}) threads[thr_name].start() self.register_thread(threads[thr_name]) # start the cleaning motion files process thr_clean = threading.Thread(None, self.yi.clean_motion_files, "clean", (self.motion_files_history, self.get_publish_files_directory), {}) thr_clean.start() self.register_thread(thr_clean) # start streaming thr_stream = threading.Thread(None, self.yi.ffserver_start, "stream", (), {}) thr_stream.start() self.register_thread(thr_stream) self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='nestdevice') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys product_id = str(self.get_config('product_id')) product_secret = str(self.get_config('product_secret')) period = int(self.get_config('period')) # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=False) self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) self.log.info(u"==> sensors: %s" % format(self.sensors)) pathData = str(self.get_data_files_directory()) # force str type for path data # ### Open the nest lib try: self.NESTclass = NESTclass(self.log, product_id, product_secret, period, dataPath=pathData) except nestException as e: self.log.error(e.value) print(e.value) self.force_leave() return # ### For each home device self.device_list = {} thread_sensors = None for a_device in self.devices: device_name = a_device["name"] device_id = a_device["id"] device_type = a_device["device_type_id"] if device_type == "nest.home": sensor_name = self.get_parameter(a_device, "name") else: sensor_name = self.get_parameter(a_device, "serial") self.device_list.update({device_id: {'name': device_name, 'named': sensor_name}}) self.log.info(u"==> Device '{0}' (id:{1}/{2}), name = {3}".format(device_name, device_id, device_type, sensor_name)) self.log.debug(u"==> Sensor list of device '{0}': '{1}'".format(device_id, self.sensors[device_id])) self.NESTclass.add_sensor(device_id, device_name, sensor_name) thread_sensors = threading.Thread(None, self.NESTclass.loop_read_sensor, 'Main_reading_sensors', (self.send_pub_data, self.get_stop()), {}) thread_sensors.start() self.register_thread(thread_sensors) self.ready()
def __init__(self, server_interfaces, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_interfaces : interfaces of HTTP server @param server_port : port of HTTP server """ Plugin.__init__(self, name = 'admin') # logging initialization self.log.info(u"Admin Server initialisation...") self.log.debug(u"locale : %s %s" % locale.getdefaultlocale()) try: try: # admin config cfg_admin = Loader('admin') config_admin = cfg_admin.load() conf_admin = dict(config_admin[1]) self.interfaces = conf_admin['interfaces'] self.port = conf_admin['port'] # if use_ssl = True, set here path for ssl certificate/key self.use_ssl = conf_admin['use_ssl'] self.key_file = conf_admin['ssl_certificate'] self.cert_file = conf_admin['ssl_key'] except KeyError: # default parameters self.interfaces = server_interfaces self.port = server_port self.use_ssl = False self.key_file = "" self.cert_file = "" self.clean_json = False self.log.error("Error while reading configuration for section [admin] : using default values instead") self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port)) # get all datatypes cli = MQSyncReq(self.zmq) msg = MQMessage() msg.set_action('datatype.get') res = cli.request('manager', msg.get(), timeout=10) if res is not None: self.datatypes = res.get_data()['datatypes'] else: self.datatypes = {} # Launch server, stats self.log.info(u"Admin Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None self.start_http() # calls the tornado.ioloop.instance().start() ### Component is ready self.ready(0) IOLoop.instance().start() except : self.log.error(u"%s" % self.get_exception())
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='disp32x8') # check if the plugin is configured. If not, this will stop the plugin and log an error # if not self.check_configured(): # return # get the devices list self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device: # self.sensors = self.get_sensors(self.devices) # self.log.info(u"==> sensors: %s" % format(self.sensors)) # INFO ==> sensors: {66: {u'set_info_number': 159}} ('device id': 'sensor name': 'sensor id') self.osdmsgtype = { "scroll": "%\n", "left": "@\n", "center": "#\n", "right": "*\n", "beep": "$\n", "time": "!\n" } # for each device ... for a_device in self.devices: # global device parameters device_name = a_device["name"] # Ex.: "" device_id = a_device["id"] # Ex.: "" displayip = self.get_parameter(a_device, "displayip") displayport = int(self.get_parameter(a_device, "displayport")) tempintsensorid = self.get_parameter(a_device, "tempintsensorid") tempextsensorid = self.get_parameter(a_device, "tempextsensorid") rainsensorid = self.get_parameter( a_device, "rainsensorid") # id sensor flowHour pluie self.log.info( u"==> Device '%s' (id:%s), address: %s:%d, sensors id tempint: %d, tempext: %d, rain: %d" % (device_name, device_id, displayip, displayport, tempintsensorid, tempextsensorid, rainsensorid)) self.display = Disp32x8(self.log, self.get_stop(), displayip, displayport, self.getMQValue) threads = {} self.log.info( u"Start to run Display loop '{0}'".format(device_name)) thr_name = "dev_{0}".format(device_id) threads[thr_name] = threading.Thread( None, self.display.run, thr_name, (tempintsensorid, tempextsensorid, rainsensorid), {}) threads[thr_name].start() self.register_thread(threads[thr_name]) self.ready()
def __init__(self, server_interfaces, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_interfaces : interfaces of HTTP server @param server_port : port of HTTP server """ Plugin.__init__(self, name='admin') # logging initialization self.log.info(u"Admin Server initialisation...") self.log.debug(u"locale : %s %s" % locale.getdefaultlocale()) try: try: cfg_rest = Loader('admin') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.interfaces = conf_rest['interfaces'] self.port = conf_rest['port'] # if rest_use_ssl = True, set here path for ssl certificate/key self.use_ssl = conf_rest['use_ssl'] self.key_file = conf_rest['ssl_certificate'] self.cert_file = conf_rest['ssl_key'] except KeyError: # default parameters self.interfaces = server_interfaces self.port = server_port self.use_ssl = False self.key_file = "" self.cert_file = "" self.clean_json = False self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port)) # get all datatypes cli = MQSyncReq(self.zmq) msg = MQMessage() msg.set_action('datatype.get') res = cli.request('manager', msg.get(), timeout=10) if res is not None: self.datatypes = res.get_data()['datatypes'] else: self.datatypes = {} # Launch server, stats self.log.info(u"Admin Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None self.start_http() # calls the tornado.ioloop.instance().start() ### Component is ready self.ready(0) IOLoop.instance().start() except: self.log.error(u"%s" % self.get_exception())
def __init__(self, name, stop_cb=None, is_manager=False, parser=None, daemonize=True, log_prefix="xplplugin_", log_on_stdout=True, test=False, nohub=False, source=None): ''' Create XplPlugin instance, which defines system handlers @param nohub : if set the hub discovery will be disabled @param source : overwrite the source value (client-device.instance) ''' Plugin.__init__(self, name, stop_cb=stop_cb, is_manager=is_manager, parser=parser, daemonize=daemonize, log_prefix=log_prefix, log_on_stdout=log_on_stdout, test=test) ### start xpl dedicated part self.log.info(u"Start of the xPL init") # start the xPL manager if 'broadcast' in self.config: broadcast = self.config['broadcast'] else: broadcast = "255.255.255.255" if 'bind_interface' in self.config: self.myxpl = Manager(self.config['bind_interface'], broadcast=broadcast, plugin=self, nohub=nohub, source=source) else: self.myxpl = Manager(broadcast=broadcast, plugin=self, nohub=nohub) # hbeat not yet called (will be called by the ready() function by a developper plugin) self.enable_hbeat_called = False # define the source (in can be used in some plugins) if source == None: self.source = "{0}-{1}.{2}".format(DMG_VENDOR_ID, self.get_plugin_name(), self.get_sanitized_hostname()) # in case we overwrite the source : self.source = source self.log.info(u"End of the xPL init")
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='hue') if not os.path.exists(str(self.get_data_files_directory())): self.log.info(u"Directory data not exist, trying create : %s", str(self.get_data_files_directory())) try: os.mkdir(str(self.get_data_files_directory())) self.log.info(u"Hue data directory created : %s" % str(self.get_data_files_directory())) except Exception as e: self.log.error(e.message) if not os.access(str(self.get_data_files_directory()), os.W_OK): self.log.error("No write access on data directory : %s" % (str(self.get_data_files_directory()))) self.devices = self.get_device_list(quit_if_no_device=True) self.commands = self.get_commands(self.devices) self.sensors = self.get_sensors(self.devices) self.ip_bridge = self.get_config("ip_bridge") self.log.info(u"==> commands: %s" % format(self.commands)) self.log.info(u"==> sensors: %s" % format(self.sensors)) try: b = Bridge( ip=self.ip_bridge, config_file_path= "/var/lib/domogik/domogik_packages/plugin_hue/data/bridge.config" ) b.connect() except: self.log.error(traceback.format_exc()) self.force_leave() data = {} self.device_list = {} huethreads = {} for a_device in self.devices: device_name = a_device["name"] device_id = a_device["id"] sensor_address = self.get_parameter(a_device, "Device") self.device_list.update( {device_id: { 'name': device_name, 'address': sensor_address }}) thr_name = "dev_{0}".format(a_device['id']) huethreads[thr_name] = threading.Thread( None, self.get_status, thr_name, (self.log, device_id, sensor_address, self.ip_bridge), {}) self.log.info(u"Starting thread" + thr_name + " with paramerters : device_id=" + str(device_id) + ", sensor_address=" + str(sensor_address) + ", ip_bridge=" + self.ip_bridge) huethreads[thr_name].start() self.register_thread(huethreads[thr_name]) self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='mqtt') # Check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # Get all config keys self.mqtthost = self.get_config("mqtt_host") self.mqttport = self.get_config("mqtt_port") self.mqttprotocol = self.get_config( "mqtt_protocol" ) # Old protocol = MQTTv31 (3), default = MQTTv311 (4) # Get the devices list, for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # Get the sensors id per device : self.sensors = self.get_sensors(self.devices) # self.log.info(u"==> sensors: %s" % format(self.sensors)) # ==> sensors: {'device id': 'sensor name': 'sensor id'} # Init MQTT self.mqttClient = MQTT(self.log, self.send_pub_data, self.get_stop(), self.mqtthost, self.mqttport, self.mqttprotocol) # Set MQTT devices list self.setMqttDevicesList(self.devices) # Connect to MQTT server try: self.mqttClient.connect() except MQTTException as e: self.log.error(e.value) print(e.value) self.force_leave() return # Start mqtt loop threads = {} thr_name = "mqtt-sub-listen" threads[thr_name] = threading.Thread(None, self.mqttClient.mqttloop, thr_name, (), {}) threads[thr_name].start() self.register_thread(threads[thr_name]) # Callback for new/update devices self.log.info(u"==> Add callback for new/update devices.") self.register_cb_update_devices(self.reload_devices) self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='mysensors') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # get the devices list self.devices = self.get_device_list(quit_if_no_device=False) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) self.mysensors_gwdevice = self.get_config("gw_device") # Init MySensors Manager self.mysensorsmanager = MySensors(self.log, self.send_data, self.create_device, self.get_stop()) # Set nodes list self.setMySensorsNodesList(self.devices) # Open the MySensors serial device try: self.mysensorsmanager.gwopen(self.mysensors_gwdevice) except MySensorsException as e: self.log.error(e.value) print(e.value) self.force_leave() return self.log.info(u"==> Launch 'gwListen' thread") thr_name = "thr_gwListen" self.thread_gwListen = threading.Thread(None, self.mysensorsmanager.gwListen, thr_name, (), {}) self.thread_gwListen.start() self.register_thread(self.thread_gwListen) self.log.info(u"==> Launch 'parseGwMsg' thread") thr_name = "thr_parseGwMsg" self.thread_parseGwMsg = threading.Thread( None, self.mysensorsmanager.parseGwMsg, thr_name, (), {}) self.thread_parseGwMsg.start() self.register_thread(self.thread_parseGwMsg) self.log.info(u"==> Add callback for new or changed devices.") self.register_cb_update_devices(self.reload_devices) self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='ecocompteur') # check if the plugin is configured. If not, this will stop the plugin and log an error #if not self.check_configured(): # return # get the devices list self.devices = self.get_device_list(quit_if_no_device=True) #self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : # {device_id1 : {"sensor_name1" : sensor_id1, # "sensor_name2" : sensor_id2}, # device_id2 : {"sensor_name1" : sensor_id1, # "sensor_name2" : sensor_id2}} self.sensors = self.get_sensors(self.devices) # create a Ecocompteur for each device threads = {} ecocompteur_list = {} for a_device in self.devices: try: # global device parameters device = self.get_parameter(a_device, "device") device_id = a_device["id"] interval = self.get_parameter(a_device, "interval") ecocompteur_list[device] = Ecocompteur(self.log, self.send_data, self.get_stop(), device, device_id, interval) # start the ecocompteur thread self.log.info( u"Start monitoring ecocompteur device '{0}'".format( device)) thr_name = "{0}".format(device) threads[thr_name] = threading.Thread( None, ecocompteur_list[device].check, thr_name, (), {}) threads[thr_name].start() self.register_thread(threads[thr_name]) except: self.log.error(u"{0}".format(traceback.format_exc())) # we don't quit plugin if an error occured # a ecocompteur device can be KO and the others be ok #self.force_leave() #return self.ready() self.log.info(u"Plugin ready :)")
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='vigilightning') # check if the plugin is configured. If not, this will stop the plugin and log an error #if not self.check_configured(): # return # get plugin parameters and web site source parameters self.vigiSource = self.get_config("wssource") self.checkTimes = self.get_config( "checktimes") * 60.0 # convert in second self.CalmMonitoring = self.checkTimes / 2 # X minutes monitoring self.OutputMonitoring = self.checkTimes * 1.5 # X minutes monitoring after last strike self._lastStrike = {"time": 0.0, "device_id": 0, 'alertLevel': 0} self._startCheck = 0.0 self._EndCheck = 0.0 self._connexionStatus = "On Wait" self._connexionError = u"" self._msg = "Plugin starting..." # get the devices list self.devices = self.get_device_list(quit_if_no_device=False) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) # create a VigiStrike and thread for each device self.vigi_Threads = {} self.vigi_List = {} self._loadDMGDevices() self.webSockect = None # Callback for new/update devices self.log.info(u"==> Add callback for new/update devices.") self.register_cb_update_devices(self.reload_devices) self._wsServer = None # Start websocket service to source web ws = threading.Thread(None, self.handle_connexion, "vigilightning-websocket-source", (), {}) ws.start() self.register_thread(ws) self.ready()
def __init__(self, name, stop_cb=None, is_manager=False, parser=None, daemonize=True, log_prefix="xplplugin_", test=False, nohub=False): ''' Create XplPlugin instance, which defines system handlers @param nohub : if set the hub discovery will be disabled ''' Plugin.__init__(self, name, stop_cb=stop_cb, is_manager=is_manager, parser=parser, daemonize=daemonize, log_prefix=log_prefix, test=test) ### start xpl dedicated part self.log.info(u"Start of the xPL init") # start the xPL manager if 'broadcast' in self.config: broadcast = self.config['broadcast'] else: broadcast = "255.255.255.255" if 'bind_interface' in self.config: self.myxpl = Manager(self.config['bind_interface'], broadcast=broadcast, plugin=self, nohub=nohub) else: self.myxpl = Manager(broadcast=broadcast, plugin=self, nohub=nohub) # hbeat not yet called (will be called by the ready() function by a developper plugin) self.enable_hbeat_called = False self.log.info(u"End of the xPL init")
def __init__(self, name, stop_cb = None, is_manager = False, parser = None, daemonize = True, log_prefix = "interface_", log_on_stdout = True, test = False, source = None): ''' Create Interface instance, which defines system handlers @param source : overwrite the source value (client-device.instance) ''' Plugin.__init__(self, name, type = "interface", stop_cb = stop_cb, is_manager = is_manager, parser = parser, daemonize = daemonize, log_prefix = log_prefix, log_on_stdout = log_on_stdout, test = test) self.log.info(u"Start of the interface init") # define the source (in can be used in some plugins) if source == None: self.source = "{0}-{1}.{2}".format(INTERFACE_VENDOR_ID, self.get_plugin_name(), self.get_sanitized_hostname()) # in case we overwrite the source : else: self.source = source ### MQ self._mq_name = self.source #self.zmq = zmq.Context() self.mq_pub = MQPub(self.zmq, self._mq_name) # subscribe the MQ for interfaces inputs MQAsyncSub.__init__(self, self.zmq, self._name, ['interface.output']) ### Context # set the context # All elements that may be added in the request sent over MQ # * media (irc, audio, sms, ...) # * text (from voice recognition) # * location (the input element location : this is configured on the input element : kitchen, garden, bedroom, ...) # * identity (from face recognition) # * mood (from kinect or anything else) # * sex (from voice recognition and post processing on the voice) self.butler_context = {"media" : None, "location" : None, "identity" : None, "mood" : None, "sex" : None } self.log.info(u"End of the interface init")
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='vigiallergen') # check if the plugin is configured. If not, this will stop the plugin and log an error #if not self.check_configured(): # return # get the devices list self.devices = self.get_device_list(quit_if_no_device=True) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) # create a Vigipollens thread for each device self.vigiallergensthreads = {} self.vigiallergens_list = {} self._loadDMGDevices() # Callback for new/update devices self.log.info(u"==> Add callback for new/update devices.") self.register_cb_update_devices(self.reload_devices) self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='body') # check if the plugin is configured. If not, this will stop the plugin and log an error # if not self.check_configured(): # return # get the devices list self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device: self.commands = self.get_commands(self.devices) self.sensors = self.get_sensors(self.devices) self.log.info(u"==> commands: %s" % format(self.commands)) self.log.info(u"==> sensors: %s" % format(self.sensors)) # INFO ==> sensors: {66: {u'set_weight': 159}} # {'device id': {'sensor name': 'sensor id'}} # for each device ... self.body_namelist = {} for a_device in self.devices: # global device parameters device_name = a_device["name"] # Ex.: "john" device_id = a_device["id"] # Ex.: "128" device_typeid = a_device["device_type_id"] # Ex.: "body.body self.log.info(u"==> Device '%s' (id:%s / %s), Sensor: '%s'" % (device_name, device_id, device_typeid, self.sensors[device_id])) # INFO ==> Device 'VDevice Binary 1' (id:112 / vdevice.info_binary), Sensor: '{u'get_info_binary': 216}' # INFO ==> Device 'VDevice Number 1' (id:113 / vdevice.info_number), Sensor: '{u'get_info_number': 217}' # INFO ==> Device 'VDevice String 1' (id:114 / vdevice.info_string), Sensor: '{u'get_info_string': 218}' self.body_namelist[device_id] = device_name self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='notify') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return self.managerClients = None # get the devices list self.refreshDevices() # get the config values self.managerClients = NotifyClientsManager(self, self.send_sensor) for a_device in self.devices : try : if self.managerClients.addClient(a_device) : self.log.info(u"Ready to work with device {0}".format(getClientId(a_device))) else : self.log.info(u"Device parameters not configured, can't create Notify Client : {0}".format(getClientId(a_device))) except: self.log.error(traceback.format_exc()) self.add_stop_cb(self.managerClients.stop) self.log.info("Plugin ready :)") if self.get_config("send_at_start") : self.managerClients.NotifyClientsConnection() self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='onewired') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys onewire_device = str(self.get_config('1-wire_device')) onewire_cache = self.get_config('1-wire_cache') # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) # self.log.info(u"==> sensors: %s" % format(self.sensors)) # ==> sensors: {'device id': 'sensor name': 'sensor id'} # Affiche: INFO ==> sensors: {4: {u'1-wire temperature': 36}, 5: {u'1-wire counter diff': 38, u'1-wire counter': 37}} # ### Open one wire network try: self.onewire = OneWireNetwork(self.log, onewire_device, onewire_cache) except OneWireException as e: self.log.error(e.value) print(e.value) self.force_leave() return # ### For each device self.device_list = {} thread_sensors = None for a_device in self.devices: # self.log.info(u"a_device: %s" % format(a_device)) device_name = a_device["name"] # Ex.: "Temp vesta" device_id = a_device["id"] # Ex.: "73" device_type = a_device[ "device_type_id"] # Ex.: "onewire.thermometer_temp | onewire.batterymonitor_voltage" sensor_properties = self.get_parameter(a_device, "properties") sensor_address = self.get_parameter(a_device, "device") self.device_list.update({ device_id: { 'name': device_name, 'address': sensor_address, 'properties': sensor_properties } }) if device_type != "onewire.pio_output_switch": sensor_interval = self.get_parameter(a_device, "interval") self.log.info( u"==> Device '{0}' (id:{1}/{2}), sensor = {3}/{4}".format( device_name, device_id, device_type, sensor_address, sensor_properties)) # Affiche: INFO ==> Device 'TempExt' (id:4/onewire.thermometer_temp), sensor = 28.7079D0040000/temperature # self.log.debug(u"==> Sensor list of device '{0}': '{1}'".format(device_id, self.sensors[device_id])) # Affiche: INFO ==> Sensor list of device id:5: '{u'onewire counter diff': 38, u'onewire counter': 37}' if sensor_interval > 0: self.log.debug(u"==> Add '%s' device in reading thread" % device_name) self.onewire.add_sensor(device_id, device_name, sensor_address, sensor_properties, sensor_interval) else: self.log.debug( u"==> Reading thread for '%s' device is DISABLED (interval < 0) !" % device_name) else: self.log.info( u"==> Device '{0}' (id:{1}/{2}), command = {3}/{4}".format( device_name, device_id, device_type, sensor_address, sensor_properties)) thread_sensors = threading.Thread( None, self.onewire.loop_read_sensor, 'Main_reading_sensors', (self.send_pub_data, self.get_stop()), {}) thread_sensors.start() self.register_thread(thread_sensors) #self.log.info(u"==> Add devices detection test.") #self.add_detected_device("onewire.thermometer_temp", "Mon device 1", "ref 1", "descrip 1", 64, "temperature", "28.5C1FD0040000") #self.add_detected_device("onewire.counter_count", "Mon device 2", "ref 2", "descrip 2", 64, "counters.A", "1D.61BF0D000000") self.ready()
def __init__(self, server_interfaces, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_interfaces : interfaces of HTTP server @param server_port : port of HTTP server """ Plugin.__init__(self, name='admin', log_prefix='core_') # logging initialization self.log.info(u"Admin Server initialisation...") self.log.debug(u"locale : {0}".format(locale.getdefaultlocale())) try: try: # admin config cfg_admin = Loader('admin') config_admin = cfg_admin.load() conf_admin = dict(config_admin[1]) self.interfaces = conf_admin['interfaces'] self.port = conf_admin['port'] # if use_ssl = True, set here path for ssl certificate/key self.use_ssl = conf_admin['use_ssl'] if self.use_ssl.strip() == "True": self.use_ssl = True self.key_file = conf_admin['ssl_key'] self.cert_file = conf_admin['ssl_certificate'] if 'clean_json' in conf_admin: self.clean_json = conf_admin['clean_json'] else: self.clean_json = False if 'rest_auth' in conf_admin and conf_admin[ 'rest_auth'] == 'True': self.rest_auth = True else: self.rest_auth = False except KeyError: # default parameters self.interfaces = server_interfaces self.port = server_port self.use_ssl = False self.key_file = "" self.cert_file = "" self.clean_json = False self.log.error( "Error while reading configuration for section [admin] : using default values instead" ) self.log.info(u"Configuration : interfaces:port = {0}:{1}".format( self.interfaces, self.port)) self.log.info(u"Configuration : use_ssl = {0}".format( self.use_ssl)) # get all datatypes cli = MQSyncReq(self.zmq) msg = MQMessage() msg.set_action('datatype.get') res = cli.request('manager', msg.get(), timeout=10) if res is not None: self.datatypes = res.get_data()['datatypes'] else: self.datatypes = {} # Launch server, stats self.log.info(u"Admin Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None self.start_http() # calls the tornado.ioloop.instance().start() ### Component is ready self.ready(0) IOLoop.instance().start() except: self.log.error(u"{0}".format(self.get_exception()))
def __init__(self, server_interfaces, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_interfaces : interfaces of HTTP server @param server_port : port of HTTP server """ Plugin.__init__(self, name = 'rest') # logging initialization self.log.info(u"Rest Server initialisation...") self.log.debug(u"locale : %s %s" % locale.getdefaultlocale()) # API version self._rest_api_version = REST_API_VERSION try: ### Config # directory data cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) self.log_dir_path = conf['log_dir_path'] # plugin installation path #self._package_path = conf['package_path'] #self._src_prefix = None #self.log.info(u"Set package path to '%s' " % self._package_path) #self._design_dir = "%s/domogik_packages/design/" % self._package_path self.package_mode = True # HTTP server ip and port try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.interfaces = conf_rest['interfaces'] self.port = conf_rest['port'] use_ssl = False # if rest_use_ssl = True, set here path for ssl certificate/key self.use_ssl = conf_rest['use_ssl'] self.key_file = conf_rest['ssl_certificate'] self.cert_file = conf_rest['ssl_key'] if 'clean_json' in conf_rest: self.clean_json = conf_rest['clean_json'] else: self.clean_json = False except KeyError: # default parameters self.interfaces = server_interfaces self.port = server_port self.use_ssl = False self.key_file = "" self.cert_file = "" self.clean_json = False self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port)) # SSL configuration try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.use_ssl = conf_rest['use_ssl'] if self.use_ssl == "True": self.use_ssl = True else: self.use_ssl = False self.ssl_certificate = conf_rest['ssl_certificate'] except KeyError: # default parameters self.use_ssl = USE_SSL self.ssl_certificate = SSL_CERTIFICATE if self.use_ssl == True: self.log.info(u"Configuration : SSL support activated (certificate : %s)" % self.ssl_certificate) else: self.log.info(u"Configuration : SSL support not activated") # File repository try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.repo_dir = conf_rest['repository'] except KeyError: # default parameters self.repo_dir = DEFAULT_REPO_DIR # Launch server, stats self.log.info(u"REST Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None # calls the tornado.ioloop.instance().start() self.start_http() ### Component is ready self.ready(0) IOLoop.instance().start() except : self.log.error(u"%s" % self.get_exception())
def __init__(self): """ Implements a listener for KNX command messages and launch background listening for KNX events """ # Declare the plugin name Plugin.__init__(self, name='knx') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return #if plugin is not configured stop initialisation knx_device = str(self.get_config('knx')) knx_cache = self.get_config('knx') self.knx_host = self.get_config( 'host_ip') #get ip address of the daemon self.knx_host_type = self.get_config( 'host_type') #get the type of daemon EIBD or KNXTOOL self.log.info('Host ip: |%s|' % self.knx_host) self.log.info('Host type: |%s|' % self.knx_host_type) self.device = self.get_device_list( quit_if_no_device=True) # get all device list self.knx = KNX(self.log, self.send_pub_data, self.knx_host, self.knx_host_type) try: self.log.info("Start listening to KNX") self.knx_listen = threading.Thread(None, self.knx.listen, "listen_knx", (), {}) self.knx_listen.start() self.register_thread(self.knx_listen) except KNXException as err: self.log.error(err.value) self.force_leave() return for item in self.device: self.log.info(item) if item["parameters"].get("address_stat", "default") != "default": if item["parameters"]["address_stat"]["value"] != "": for sensor in item["sensors"]: sensors_list[item["parameters"]["address_stat"] ["value"]] = item["sensors"][sensor]["id"] if datapoint_list.get( item["parameters"]["address_stat"]["value"], "Default") == "Default": datapoint_list[item["parameters"]["address_stat"] ["value"]] = item["parameters"][ "Stat_Datapoint"]["value"] else: if item["parameters"]["address_cmd"]["value"] != "": sensors_list[item["parameters"]["address_cmd"][ "value"]] = item["sensors"]["state"]["id"] if item["parameters"].get( "address_cmd", "default") != "default": # problème si sensor alone if item["parameters"]["address_cmd"]["value"] != "": for command in item["commands"]: commands_list[item["commands"][command]["id"]] = item[ "parameters"]["address_cmd"]["value"] if datapoint_list.get( item["parameters"]["address_cmd"]["value"], "Default") == "Default": datapoint_list[item["parameters"]["address_cmd"] ["value"]] = item["parameters"][ "Cmd_Datapoint"]["value"] else: self.log.error("No command group for item") self.read_sensors() self.log.info('Sensor list: %s' % sensors_list) self.log.info('Command List: %s' % commands_list) self.log.info('Datapoint dict: %s' % datapoint_list) self.register_cb_update_devices(self.reload_devices) self.log.info("Plugin ready :)") self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='nestdevice') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys product_id = str(self.get_config('product_id')) product_secret = str(self.get_config('product_secret')) period = int(self.get_config('period')) # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=False) self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) self.log.info(u"==> sensors: %s" % format(self.sensors)) pathData = str( self.get_data_files_directory()) # force str type for path data # ### Open the nest lib try: self.NESTclass = NESTclass(self.log, product_id, product_secret, period, dataPath=pathData) except nestException as e: self.log.error(e.value) print(e.value) self.force_leave() return # ### For each home device self.device_list = {} thread_sensors = None for a_device in self.devices: device_name = a_device["name"] device_id = a_device["id"] device_type = a_device["device_type_id"] if device_type == "nest.home": sensor_name = self.get_parameter(a_device, "name") else: sensor_name = self.get_parameter(a_device, "serial") self.device_list.update( {device_id: { 'name': device_name, 'named': sensor_name }}) self.log.info(u"==> Device '{0}' (id:{1}/{2}), name = {3}".format( device_name, device_id, device_type, sensor_name)) self.log.debug(u"==> Sensor list of device '{0}': '{1}'".format( device_id, self.sensors[device_id])) self.NESTclass.add_sensor(device_id, device_name, sensor_name) thread_sensors = threading.Thread( None, self.NESTclass.loop_read_sensor, 'Main_reading_sensors', (self.send_pub_data, self.get_stop()), {}) thread_sensors.start() self.register_thread(thread_sensors) self.ready()
def __init__(self): ### Option parser parser = ArgumentParser() parser.add_argument("-i", action="store_true", dest="interactive", default=False, \ help="Butler interactive mode (must be used WITH -f).") Plugin.__init__(self, name='butler', parser=parser, log_prefix='core_') ### MQ # MQ publisher #self._mq_name = "interface-{0}.{1}".format(self._name, self.get_sanitized_hostname()) self._mq_name = "butler" #self.zmq = zmq.Context() self.pub = MQPub(self.zmq, self._mq_name) # subscribe the MQ for interfaces inputs self.add_mq_sub('interface.input') # devices updates self.add_mq_sub('device.update') ### Configuration elements try: cfg = Loader('butler') config = cfg.load() conf = dict(config[1]) self.lang = conf['lang'] self.butler_name = conf['name'] self.log.debug(u"The butler configured name is '{0}'".format( self.butler_name)) self.butler_name_cleaned = clean_input(conf['name']) self.log.debug(u"The butler cleaned name is '{0}'".format( self.butler_name_cleaned)) self.butler_sex = conf['sex'] self.butler_mood = None if self.butler_sex not in SEX_ALLOWED: self.log.error( u"Exiting : the butler sex configured is not valid : '{0}'. Expecting : {1}" .format(self.butler_sex, SEX_ALLOWED)) self.force_leave() return except: self.log.error( u"Exiting : error while reading the configuration file '{0}' : {1}" .format(CONFIG_FILE, traceback.format_exc())) self.force_leave() return # user name (default is 'localuser') # this is not used for now on Domogik side self.user_name = "localuser" ### Prepare the brain # - validate packages # Start the brain :) self.brain = RiveScript(utf8=True) # set rivescript variables # Configure bot variables # all must be lower case.... self.log.info(u"Configuring name and sex : {0}, {1}".format( self.butler_name_cleaned.lower(), self.butler_sex.lower())) self.brain.set_variable(u"name", self.butler_name_cleaned.lower()) self.brain.set_variable(u"fullname", self.butler_name.lower()) self.brain.set_variable(u"sex", self.butler_sex.lower()) # set the PYTHONPATH sys.path.append(self.get_libraries_directory()) # load the brain self.brain_content = None self.learn_content = None self.not_understood_content = None self.load_all_brain() # shortcut to allow the core brain package to reload the brain for learning self.brain.reload_butler = self.reload # shortcut to allow the core brain package to do logging and access the devices in memory self.brain.log = self.log self.brain.devices = [] # will be loaded in self.reload_devices() # history self.history = [] # load all known devices self.reload_devices() self.log.info( u"*** Welcome in {0} world, your digital assistant! ***".format( self.butler_name)) # for chat more only #self.log.info(u"You may type /quit to let {0} have a break".format(self.butler_name)) ### Interactive mode if self.options.interactive: self.log.info(u"Launched in interactive mode : running the chat!") # TODO : run as a thread #self.run_chat() thr_run_chat = Thread(None, self.run_chat, "run_chat", (), {}) thr_run_chat.start() else: self.log.info(u"Not launched in interactive mode") ### TODO #self.add_stop_cb(self.shutdown) self.log.info(u"Butler initialized") self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='withingdevice') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys api_key = str(self.get_config('api_key')) api_secret = str(self.get_config('api_secret')) period = int(self.get_config('period')) pathData = str( self.get_data_files_directory()) # force str type for path data # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=False) self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) self.log.info(u"==> sensors: %s" % format(self.sensors)) # ### Open the wihting lib try: self.WITHINGclass = WITHINGclass(self.log, api_key, api_secret, period, dataPath=pathData) except withingException as e: self.log.error(e.value) self.force_leave() return # ### For each device self.device_list = {} thread_sensors = None for a_device in self.devices: self.log.info(u"a_device: %s" % format(a_device)) device_name = a_device["name"] device_id = a_device["id"] device_type = a_device["device_type_id"] user_id = self.get_parameter(a_device, "userid") self.device_list.update( {device_id: { 'name': device_name, 'named': user_id }}) self.log.info(u"==> Device '{0}' (id:{1}/{2}), name = {3}".format( device_name, device_id, device_type, user_id)) self.log.debug(u"==> Sensor list of device '{0}': '{1}'".format( device_id, self.sensors[device_id])) self.WITHINGclass.add_sensor(device_id, device_name, device_type, user_id) self.log.debug(u"==> Launch reading thread for '%s' device !" % device_name) thread_sensors = threading.Thread( None, self.WITHINGclass.loop_read_sensor, 'Main_reading_sensors', (self.send_pub_data, self.send_data, self.get_stop()), {}) thread_sensors.start() self.register_thread(thread_sensors) self.ready()
def __init__(self, server_interfaces, server_port): """ Initiate DbHelper, Logs and config Then, start HTTP server and give it initialized data @param server_interfaces : interfaces of HTTP server @param server_port : port of HTTP server """ Plugin.__init__(self, name='rest') # logging initialization self.log.info(u"Rest Server initialisation...") self.log.debug(u"locale : %s %s" % locale.getdefaultlocale()) # API version self._rest_api_version = REST_API_VERSION try: ### Config # directory data cfg = Loader('domogik') config = cfg.load() conf = dict(config[1]) self.log_dir_path = conf['log_dir_path'] # plugin installation path #self._package_path = conf['package_path'] #self._src_prefix = None #self.log.info(u"Set package path to '%s' " % self._package_path) #self._design_dir = "%s/domogik_packages/design/" % self._package_path self.package_mode = True # HTTP server ip and port try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.interfaces = conf_rest['interfaces'] self.port = conf_rest['port'] use_ssl = False # if rest_use_ssl = True, set here path for ssl certificate/key self.use_ssl = conf_rest['use_ssl'] self.key_file = conf_rest['ssl_certificate'] self.cert_file = conf_rest['ssl_key'] if 'clean_json' in conf_rest: self.clean_json = conf_rest['clean_json'] else: self.clean_json = False except KeyError: # default parameters self.interfaces = server_interfaces self.port = server_port self.use_ssl = False self.key_file = "" self.cert_file = "" self.clean_json = False self.log.info(u"Configuration : interfaces:port = %s:%s" % (self.interfaces, self.port)) # SSL configuration try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.use_ssl = conf_rest['use_ssl'] if self.use_ssl == "True": self.use_ssl = True else: self.use_ssl = False self.ssl_certificate = conf_rest['ssl_certificate'] except KeyError: # default parameters self.use_ssl = USE_SSL self.ssl_certificate = SSL_CERTIFICATE if self.use_ssl == True: self.log.info( u"Configuration : SSL support activated (certificate : %s)" % self.ssl_certificate) else: self.log.info(u"Configuration : SSL support not activated") # File repository try: cfg_rest = Loader('rest') config_rest = cfg_rest.load() conf_rest = dict(config_rest[1]) self.repo_dir = conf_rest['repository'] except KeyError: # default parameters self.repo_dir = DEFAULT_REPO_DIR # Launch server, stats self.log.info(u"REST Initialisation OK") self.add_stop_cb(self.stop_http) self.server = None # calls the tornado.ioloop.instance().start() self.start_http() ### Component is ready self.ready(0) IOLoop.instance().start() except: self.log.error(u"%s" % self.get_exception())
def __init__(self): ### Option parser parser = ArgumentParser() parser.add_argument("-i", action="store_true", dest="interactive", default=False, \ help="Butler interactive mode (must be used WITH -f).") Plugin.__init__(self, name = 'butler', parser = parser) ### MQ # MQ publisher #self._mq_name = "interface-{0}.{1}".format(self._name, self.get_sanitized_hostname()) self._mq_name = "butler" #self.zmq = zmq.Context() self.pub = MQPub(self.zmq, self._mq_name) # subscribe the MQ for interfaces inputs MQAsyncSub.__init__(self, self.zmq, self._name, ['interface.input']) ### Configuration elements try: cfg = Loader('butler') config = cfg.load() conf = dict(config[1]) self.lang = conf['lang'] self.butler_name = conf['name'] self.butler_sex = conf['sex'] self.butler_mood = None if self.butler_sex not in SEX_ALLOWED: self.log.error(u"Exiting : the butler sex configured is not valid : '{0}'. Expecting : {1}".format(self.butler_sex, SEX_ALLOWED)) self.force_leave() return except: self.log.error(u"Exiting : error while reading the configuration file '{0}' : {1}".format(CONFIG_FILE, traceback.format_exc())) self.force_leave() return # user name (default is 'localuser') # this is not used for now on Domogik side self.user_name = "localuser" ### Prepare the brain # - validate packages # Start the brain :) self.brain = RiveScript(utf8=True) # set rivescript variables # Configure bot variables # all must be lower case.... self.log.info("Configuring name and sex : {0}, {1}".format(self.butler_name.lower(), self.butler_sex.lower())) self.brain.set_variable("name", self.butler_name.lower()) self.brain.set_variable("fullname", self.butler_name.lower()) self.brain.set_variable("sex", self.butler_sex.lower()) # set the PYTHONPATH sys.path.append(self.get_libraries_directory()) # load the brain self.brain_content = None self.learn_content = None self.not_understood_content = None self.load_all_brain() # shortcut to allow the core brain package to reload the brain for learning self.brain.reload_butler = self.reload # history self.history = [] print(u"*** Welcome in {0} world, your digital assistant! ***".format(self.butler_name)) print(u"You may type /quit to let {0} have a break".format(self.butler_name)) ### Interactive mode if self.options.interactive: self.log.info(u"Launched in interactive mode : running the chat!") # TODO : run as a thread #self.run_chat() thr_run_chat = Thread(None, self.run_chat, "run_chat", (), {}) thr_run_chat.start() else: self.log.info(u"Not launched in interactive mode") ### TODO #self.add_stop_cb(self.shutdown) self.log.info(u"Butler initialized") self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='onewired') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys onewire_device = str(self.get_config('1-wire_device')) onewire_cache = self.get_config('1-wire_cache') # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=True) # self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) # self.log.info(u"==> sensors: %s" % format(self.sensors)) # ==> sensors: {'device id': 'sensor name': 'sensor id'} # Affiche: INFO ==> sensors: {4: {u'1-wire temperature': 36}, 5: {u'1-wire counter diff': 38, u'1-wire counter': 37}} # ### Open one wire network try: onewire = OneWireNetwork(self.log, onewire_device, onewire_cache) except OneWireException as e: self.log.error(e.value) print(e.value) self.force_leave() return # ### For each device threads = {} for a_device in self.devices: # self.log.info(u"a_device: %s" % format(a_device)) device_name = a_device["name"] # Ex.: "Temp vesta" device_id = a_device["id"] # Ex.: "73" device_type = a_device["device_type_id"] # Ex.: "onewire.thermometer_temp | onewire.batterymonitor_voltage" sensor_interval = self.get_parameter(a_device, "interval") sensor_properties = self.get_parameter(a_device, "properties") sensor_address = self.get_parameter(a_device, "device") if device_type != "onewire.pio_output": self.log.info(u"==> Device '{0}' (id:{1}/{2}), sensor = {3}/{4}".format(device_name, device_id, device_type, sensor_address, sensor_properties)) # Affiche: INFO ==> Device 'TempExt' (id:4/onewire.thermometer_temp), sensor = 28.7079D0040000/temperature self.log.info(u"==> Sensor list of device '{0}': '{1}'".format(device_id, self.sensors[device_id])) # Affiche: INFO ==> Sensor list of device id:5: '{u'1-wire counter diff': 38, u'1-wire counter': 37}' if sensor_interval > 0: self.log.info(u"==> Launch thread for '%s' device !" % device_name) thr_name = "dev_{0}".format(a_device['id']) threads[thr_name] = threading.Thread(None, OnewireRead, thr_name, (self.log, onewire, device_id, device_name, sensor_address, sensor_properties, sensor_interval, self.send_data, self.get_stop()), {}) threads[thr_name].start() self.register_thread(threads[thr_name]) self.log.info(u"==> Wait some time before running the next scheduled threads ...") time.sleep(5) # Wait some time to not start the threads with the same interval et the same time. else: self.log.info(u"==> Onewire sensor thread '%s' for '%s' device is DISABLED (interval < 0) !" % (thr_name, device_name)) else: pass # TODO: For ouput => listener ! self.ready()
def __init__(self): """ Init plugin """ Plugin.__init__(self, name='ebusd') # check if the plugin is configured. If not, this will stop the plugin and log an error if not self.check_configured(): return # ### get all config keys device = self.get_config("device") # ### get the devices list # for this plugin, if no devices are created we won't be able to use devices. self.devices = self.get_device_list(quit_if_no_device=False) self.log.info(u"==> device: %s" % format(self.devices)) # get the sensors id per device : self.sensors = self.get_sensors(self.devices) self.log.info(u"==> sensors: %s" % format(self.sensors)) # ### Open the ebus manager try: self.ebusdclass = ebusdclass(self.log, device) except ebusdException as e: self.log.error(e.value) self.force_leave() return # try opening try: self.ebusdclass.open(device) except ebusdException as ex: self.log.error(ex.value) self.force_leave() return # ### For each device self.device_list = {} thread_sensors = None for a_device in self.devices: device_name = a_device["name"] device_id = a_device["id"] device_type = a_device["device_type_id"] sensor_address = self.get_parameter(a_device, "address") self.device_list.update({device_id: {'name': device_name, 'named': sensor_address}}) self.log.info( u"==> Device '{0}' (id:{1}/{2}), name = {3}".format(device_name, device_id, device_type, sensor_address)) self.log.debug(u"==> Sensor list of device '{0}': '{1}'".format(device_id, self.sensors[device_id])) self.ebusdclass.add_sensor(device_id, device_name, device_type, sensor_address) thread_sensors = threading.Thread(None, self.ebusdclass.read_bus_for_sensor, 'Main_reading_sensors', (self.send_data, self.get_stop()), {}) thread_sensors.start() self.register_thread(thread_sensors) self.ready()