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):
""" 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 on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
if msg.get_action() == "client.cmd":
data = msg.get_data()
self.log.info(u"==> Received 0MQ messages data: %s" % format(data))
# ==> Received 0MQ messages data: {u'command_id': 35, u'value': u'1', u'device_id': 112}
# ==> Received 0MQ messages data: {u'command_id': 36, u'value': u'128', u'device_id': 113}
# ==> Received 0MQ messages data: {u'command_id': 37, u'value': u'Bonjour', u'device_id': 114}
# search for related device
for a_device in self.devices:
for a_cmd in a_device['commands']:
if data['command_id'] == a_device['commands'][a_cmd]['id']:
# As we will just execute a shell script, we can't really known if the command will be ok and how long it will take...
# so we respond first on MQ to say we got the request
self.log.info("Reply to command 0MQ")
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
reply_msg.add_data('status', True)
reply_msg.add_data('reason', '')
self.reply(reply_msg.get())
# Now, launch the speak action !
ip = self.get_parameter(a_device, "ip")
lang = 'fr-FR'
thr_speak = threading.Thread(None,
self.yi.speak,
"speak",
(ip, lang, data['text'], self.get_data_files_directory),
{})
thr_speak.start()
self.register_thread(thr_speak)
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 = "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 on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
#self.log.debug(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
data = msg.get_data()
self.log.debug(u"==> Received 0MQ messages data: %s" %
format(data))
# ==> Received 0MQ messages data: {u'command_id': 35, u'value': u'1', u'device_id': 112}
# ==> Received 0MQ messages data: {u'command_id': 36, u'value': u'128', u'device_id': 113}
# ==> Received 0MQ messages data: {u'command_id': 37, u'value': u'Bonjour', u'device_id': 114}
sensor_id = self.get_related_sensor_id(data['device_id'],
data['command_id'])
self.log.debug(u"Storing data for sensor_id = {0} : '{1}'".format(
sensor_id, data["value"]))
status, reason = self.send_data(sensor_id, data["value"])
self.log.info("Reply to command 0MQ")
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
reply_msg.add_data('status', status)
reply_msg.add_data('reason', reason)
self.reply(reply_msg.get())
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 on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
self.log.info(u"Received 0MQ messages: {0}".format(msg))
action = msg.get_action().split(".")
if action[0] == "client" and action[1] == "cmd" :
# action on dmg device
data = msg.get_data()
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
idsClient = self.managerClients.getIdsClient(data)
find = False
if idsClient != [] :
for id in idsClient :
client = self.managerClients.getClient(id)
if client :
self.log.debug(u"Handle requested action for Notify client {0} : {1}".format(id, data))
commands = client.getDmgCommands()
for cmd in commands :
if commands[cmd]['id'] == data['command_id'] :
find = True
client.handle_cmd(data)
reply_msg.add_data('status', True)
reply_msg.add_data('reason', None)
break
if not find :
self.log.warning(u"Requested action received for unknown Notify client : {0}".format(data))
reply_msg.add_data('status', False)
reply_msg.add_data('reason', u"Requested action received for unknown Notify client : {0}".format(data))
self.log.debug(u"Reply to MQ: {0}".format(reply_msg.get()))
self.reply(reply_msg.get())
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 force_leave(self, status=False, return_code=None):
""" Leave threads & timers
"""
### Do the xPL related tasks
# send hbeat.end message
self._send_hbeat_end()
### finally call the function from the Plugin class to do the common things
# this is called as the end ad the MQ IOLoop is a blocking call
Plugin.force_leave(self, status, return_code)
def force_leave(self, status = False, return_code = None):
""" Leave threads & timers
"""
### Do the xPL related tasks
# send hbeat.end message
self._send_hbeat_end()
### finally call the function from the Plugin class to do the common things
# this is called as the end ad the MQ IOLoop is a blocking call
Plugin.force_leave(self, status, return_code)
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
reason = None
status = True
data = msg.get_data()
device_id = data["device_id"]
command_id = data["command_id"]
if device_id not in self.device_list:
self.log.error(
u"### MQ REQ command, Device ID '%s' unknown, Have you restarted the plugin after device creation ?" % device_id)
status = False
reason = u"Plugin nestdevice: Unknown device ID %d" % device_id
self.send_rep_ack(status, reason, command_id, "unknown");
return
device_name = self.device_list[device_id]["name"]
self.log.info(u"==> Received for device '%s' MQ REQ command message: %s" % (device_name, format(data)))
for a_device in self.devices:
if a_device["id"] == device_id:
if a_device["device_type_id"] == "nest.home":
sensor_name = self.get_parameter(a_device, "name")
self.log.info(u"==> Received for nest name or serial '%s' MQ REQ command message: %s" % (
sensor_name, format(data)))
status, reason = self.NESTclass.writeState(sensor_name, "away", data["away"])
elif a_device["device_type_id"] == "nest.thermostat":
sensor_name = self.get_parameter(a_device, "serial")
self.log.info(u"==> Received for nest name or serial '%s' MQ REQ command message: %s" % (
sensor_name, format(data)))
if "temperature" in data:
status, reason = self.NESTclass.writeState(sensor_name, "temperature", data["temperature"])
elif "mode" in data:
status, reason = self.NESTclass.writeState(sensor_name, "mode", data["mode"])
elif "fan" in data:
status, reason = self.NESTclass.writeState(sensor_name, "fan", data["fan"])
else:
self.log.error(u"==> Command not implemented yet")
# This should be eaisier but not available
# sensor_name = self.get_parameter(self.device_list[device_id], "name")
#
# TODO return status by calling back for good sensors
# if status:
# self.send_pub_data(device_id, format(data))
# self.send_pub_data(device_id, data["away"])
self.send_rep_ack(status, reason, command_id, device_name);
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='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='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 ready(self, ioloopstart=1):
""" to call at the end of the __init__ of classes that inherits of XplPlugin
"""
### First, Do only the xPL related tasks
# activate xpl hbeat
if self.enable_hbeat_called == True:
self.log.error(u"in ready() : enable_hbeat() function already called : the plugin may not be fully converted to the 0.4+ Domogik format")
else:
self.enable_hbeat()
# send the status for the xpl hbeat
self.myxpl.update_status(2)
### finally call the function from the Plugin class to do the common things
# this is called as the end ad the MQ IOLoop is a blocking call
Plugin.ready(self, ioloopstart)
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
# self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
reason = None
status = True
data = msg.get_data()
self.log.info(u"==> Received 0MQ messages data: %s" % format(data))
self.log.info(u"Reply to command 0MQ")
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
reply_msg.add_data('status', status)
reply_msg.add_data('reason', reason)
self.reply(reply_msg.get())
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
### NON TESTE !
Plugin.on_mdp_request(self, msg)
#self.log.info(u"==> Received MQ message: %s" % format(msg))
# => MQ Request received : <MQMessage(action=client.cmd, data='{u'state': u'1', u'command_id': 14, u'device_id': 39}')>
if msg.get_action() == "client.cmd":
data = msg.get_data()
#self.log.debug(u"==> Received MQ REQ command message: %s" % format(data))
# DEBUG ==> Received MQ REQ command message: {u'value': u'1', u'command_id': 50, u'device_id': 139}
device_id = data["device_id"]
command_id = data["command_id"]
# {"44.0": {"name": "Bureau", "dmgid": "120", "vtype": "V_STATUS"}}
for node in self.mysensorsmanager.nodes:
if '255' not in node:
if nodes[node]['dmgid'] == device_id:
nodesensor_name = nodes[node]['name'] # "Relay #1"
nodesensor_vtype = nodes[node]['vtype'] # "V_STATUS"
break
if nodesensor_vtype in [
"V_STATUS", "V_UP", "V_DOWN", "V_STOP", "V_PERCENTAGE",
"V_IR_SEND"
]:
msg = node.replace(
".",
";") + '1;0;' + self.mysensorsmanager.setreqType.index(
nodesensor_vtype) + ";" + data["value"] + "\n"
# msg = "42;0;1;0;2;1\n" nodeid;childsensorid;set command;no ack;vtype;value\n
# Command from the controller (1 = SET), Outgoing message to node 42 child sensor 0, Set V_STATUS (2) variable to 1 (turn on). No ack is requested from destination node.
self.log.info(
u"==> Send SET message '%s' for device '%s/%s' (id:%s) to Gateway"
% (msg, nodesensor_name, nodesensor_vtype.lower(),
device_id))
self.mysensorsmanager.msgSendQueue.put(msg)
# Reply MQ REP (acq) to REQ command
self.send_rep_ack(True, None, command_id, device_name)
else:
self.log.error(
u"### Node sensor vtype not found for device '%s' (id:%s)"
% (nodesensor_name, device_id))
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 ready(self, ioloopstart=1):
""" to call at the end of the __init__ of classes that inherits of XplPlugin
"""
### First, Do only the xPL related tasks
# activate xpl hbeat
if self.enable_hbeat_called == True:
self.log.error(
u"in ready() : enable_hbeat() function already called : the plugin may not be fully converted to the 0.4+ Domogik format"
)
else:
self.enable_hbeat()
# send the status for the xpl hbeat
self.myxpl.update_status(2)
### finally call the function from the Plugin class to do the common things
# this is called as the end ad the MQ IOLoop is a blocking call
Plugin.ready(self, ioloopstart)
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
# self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
data = msg.get_data()
self.log.info(u"==> Received 0MQ messages data: %s" % format(data))
# ==> Received 0MQ messages data: {u'command_id': 35, u'value': u'1', u'device_id': 112}
# ==> Received 0MQ messages data: {u'command_id': 36, u'value': u'128', u'device_id': 113}
# ==> Received 0MQ messages data: {u'command_id': 37, u'value': u'Bonjour', u'device_id': 114}
status, reason = self.send_data(data["device_id"], data["value"])
self.log.info("Reply to command 0MQ")
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
reply_msg.add_data('status', status)
reply_msg.add_data('reason', reason)
self.reply(reply_msg.get())
def on_mdp_request(self, msg):
""" Routine call when a MQ message arrive
"""
Plugin.on_mdp_request(self, msg)
command = ""
self.log.info("Test: %s" % msg)
if msg.get_action() == "client.cmd":
data = msg.get_data()
self.log.info(data)
cmdadr = commands_list[data["command_id"]]
reason = None
status = True
val = data['value']
self.log.info(datapoint_list)
command_id = data['device_id']
datatype = datapoint_list[cmdadr]
value = encodeKNX(datatype, val)
data_type = value[0]
valeur = value[1]
if data_type == "s":
command = "groupswrite ip:%s %s %s" % (self.knx_host, cmdadr,
valeur)
if self.knx_host_type == "KNXTOOL":
command = "knxtool " + command
if data_type == "l":
command = "groupwrite ip:%s %s %s" % (self.knx_host, cmdadr,
valeur)
if self.knx_host_type == "KNXTOOL":
command = "knxtool " + command
if command != "":
subp = subprocess.Popen(command, shell=True)
else:
self.log.info("erreur command non définir, type cmd= %s" %
type_cmd)
reason = "Command not define"
status = False
self.send_rep_ack(status, reason, command_id)
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
if msg.get_action() == "client.cmd":
data = msg.get_data()
self.log.info(u"==> Received 0MQ message data: %s" % format(data))
# INFO ==> Received 0MQ message data: {u'message': u'Bonjour', u'command_id': 49, u'position': u'center', u'device_id': 132}
self.display.osdmsg = data['message'] + self.osdmsgtype[
data['position']]
self.log.info(u"==> Message = '%s'" % self.display.osdmsg)
status = True
reason = None
self.log.info("Reply to command 0MQ")
reply_msg = MQMessage()
reply_msg.set_action('client.cmd.result')
reply_msg.add_data('status', status)
reply_msg.add_data('reason', reason)
self.reply(reply_msg.get())
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 on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
# self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
reason = None
status = True
data = msg.get_data()
device_id = data["device_id"]
command_id = data["command_id"]
if device_id not in self.mqttdevices_list:
self.log.error(u"### MQ REQ command, Device ID '%s' unknown" %
device_id)
status = False
reason = u"Plugin mqtt: Unknown device ID %d" % device_id
self.send_rep_ack(status, reason, command_id, "unknown")
# Reply MQ REP (acq) to REQ command
return
device_name = self.mqttdevices_list[device_id]["name"]
self.log.info(
u"==> Received for device '%s' MQ REQ command message: %s" %
(device_name, format(data))
) # {u'value': u'1', u'command_id': 80, u'device_id': 193}
status, reason = self.mqttClient.pubcmd(
self.mqttdevices_list[device_id]["topic"],
self.mqttdevices_list[device_id]["qos"], data["value"],
device_id)
if status:
self.send_pub_data(device_id,
data["value"]) # Update sensor command.
# Reply MQ REP (acq) to REQ command
self.send_rep_ack(status, reason, command_id, device_name)
def on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
# self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
reason = None
status = True
data = msg.get_data()
device_id = data["device_id"]
command_id = data["command_id"]
if device_id not in self.device_list:
self.log.error(
u"### MQ REQ command, Device ID '%s' unknown, Have you restarted the plugin after device creation ?"
% device_id)
status = False
reason = u"Plugin onewired: Unknown device ID %d" % device_id
self.send_rep_ack(status, reason, command_id, "unknown")
# Reply MQ REP (acq) to REQ command
return
device_name = self.device_list[device_id]["name"]
self.log.info(
u"==> Received for device '%s' MQ REQ command message: %s" %
(device_name, format(data))
) # {u'command_id': 70, u'value': u'1', u'device_id': 169}
status, reason = self.onewire.writeSensor(
self.device_list[device_id]["address"],
self.device_list[device_id]["properties"], data["value"])
if status:
self.send_pub_data(device_id,
data["value"]) # Update sensor command.
# Reply MQ REP (acq) to REQ command
self.send_rep_ack(status, reason, command_id, device_name)
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:
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()
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, 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, 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='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 on_mdp_request(self, msg):
""" Called when a MQ req/rep message is received
"""
Plugin.on_mdp_request(self, msg)
self.log.info(u"==> Received 0MQ messages: %s" % format(msg))
if msg.get_action() == "client.cmd":
reason = None
status = True
data = msg.get_data()
device_id = data["device_id"]
command_id = data["command_id"]
if device_id not in self.device_list:
self.log.error(
u"### MQ REQ command, Device ID '%s' unknown, Have you restarted the plugin after device creation ?"
% device_id)
status = False
reason = u"Plugin nestdevice: Unknown device ID %d" % device_id
self.send_rep_ack(status, reason, command_id, "unknown")
return
device_name = self.device_list[device_id]["name"]
self.log.info(
u"==> Received for device '%s' MQ REQ command message: %s" %
(device_name, format(data)))
for a_device in self.devices:
if a_device["id"] == device_id:
if a_device["device_type_id"] == "nest.home":
sensor_name = self.get_parameter(a_device, "name")
self.log.info(
u"==> Received for nest name or serial '%s' MQ REQ command message: %s"
% (sensor_name, format(data)))
status, reason = self.NESTclass.writeState(
sensor_name, "away", data["away"])
elif a_device["device_type_id"] == "nest.thermostat":
sensor_name = self.get_parameter(a_device, "serial")
self.log.info(
u"==> Received for nest name or serial '%s' MQ REQ command message: %s"
% (sensor_name, format(data)))
if "temperature" in data:
status, reason = self.NESTclass.writeState(
sensor_name, "temperature",
data["temperature"])
elif "mode" in data:
status, reason = self.NESTclass.writeState(
sensor_name, "mode", data["mode"])
elif "fan" in data:
status, reason = self.NESTclass.writeState(
sensor_name, "fan", data["fan"])
else:
self.log.error(u"==> Command not implemented yet")
# This should be eaisier but not available
# sensor_name = self.get_parameter(self.device_list[device_id], "name")
#
# TODO return status by calling back for good sensors
# if status:
# self.send_pub_data(device_id, format(data))
# self.send_pub_data(device_id, data["away"])
self.send_rep_ack(status, reason, command_id, device_name)