Confronta commit
No commits in common. "master" and "dev_db" have entirely different histories.
6
.gitmodules
esterno
6
.gitmodules
esterno
@ -10,9 +10,3 @@
|
||||
[submodule "geo"]
|
||||
path = geo
|
||||
url = https://git.mount-mockery.de/pylib/geo.git
|
||||
[submodule "devdi"]
|
||||
path = devdi
|
||||
url = https://git.mount-mockery.de/smarthome/smart_devdi.git
|
||||
[submodule "smart_devices"]
|
||||
path = smart_devices
|
||||
url = https://git.mount-mockery.de/smarthome/smart_devices.git
|
||||
|
||||
2
.vscode/launch.json
esterno
2
.vscode/launch.json
esterno
@ -6,7 +6,7 @@
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Python: Main File execution",
|
||||
"type": "debugpy",
|
||||
"type": "python",
|
||||
"request": "launch",
|
||||
"program": "${workspaceFolder}/smart_brain.py",
|
||||
"console": "integratedTerminal",
|
||||
|
||||
23
.vscode/settings.json
esterno
23
.vscode/settings.json
esterno
@ -1,14 +1,11 @@
|
||||
{
|
||||
"python.defaultInterpreterPath": "./venv/bin/python",
|
||||
"autopep8.args": ["--max-line-length=150"],
|
||||
"[python]": {
|
||||
"python.formatting.provider": "none",
|
||||
"editor.defaultFormatter": "ms-python.autopep8",
|
||||
"editor.formatOnSave": true
|
||||
},
|
||||
"editor.fontSize": 14,
|
||||
"emmet.includeLanguages": { "django-html": "html" },
|
||||
"python.testing.pytestArgs": ["-v", "--cov", "--cov-report=xml", "__test__"],
|
||||
"python.testing.unittestEnabled": false,
|
||||
"python.testing.pytestEnabled": true
|
||||
}
|
||||
"python.defaultInterpreterPath": "./venv/bin/python",
|
||||
"editor.formatOnSave": true,
|
||||
"autopep8.args": [
|
||||
"--max-line-length=150"
|
||||
],
|
||||
"editor.fontSize": 14,
|
||||
"emmet.includeLanguages": {
|
||||
"django-html": "html"
|
||||
}
|
||||
}
|
||||
133
Makefile
133
Makefile
@ -1,133 +0,0 @@
|
||||
# git helper Makefile: Version 2.6 (2025-08-11)
|
||||
default: help
|
||||
|
||||
.ONESHELL:
|
||||
SHELL = /usr/bin/bash
|
||||
MAKEFLAGS += --no-print-directory
|
||||
.SILENT:
|
||||
|
||||
-include __make.d__/*.mk
|
||||
|
||||
GIT_FLAG = ./.git
|
||||
VENV_FLAG = ./.venv_required
|
||||
VENV_FOLDER = ./venv
|
||||
|
||||
localhelp:
|
||||
|
||||
help:
|
||||
echo "Possible common options are:"
|
||||
echo " - init - Initialise the repository and all folders below with a Makefile"
|
||||
echo " - giti - Get the git status of all submodules including their submodules"
|
||||
echo " - update_submodules - Set all submodules to remote master"
|
||||
echo " - venv_flag - Set the venev flag for the base folder. A venv will be generated"
|
||||
echo " - clean - clean up"
|
||||
echo " - deepclean - clean up this and all Makefiles below"
|
||||
$(MAKE) localhelp
|
||||
echo "You are able to create files make.d/*.mk and add local rules there. "
|
||||
echo " - localinit: print_head - Will be executed as last step in the init process."
|
||||
echo " - localhelp: print_head - Will be executed in th middle of the help text generation"
|
||||
echo " - localclean:print_head - Will be executed before the clean rule"
|
||||
|
||||
localinit:
|
||||
|
||||
init: print_head
|
||||
# Init git repo
|
||||
if [[ -e $(GIT_FLAG) ]]; then
|
||||
echo -e "\033[1;33mInitialising git submodules...\e[0m"
|
||||
git submodule init
|
||||
git submodule update
|
||||
echo
|
||||
fi
|
||||
# Init submodules
|
||||
SUBDIRS=$$(find . -maxdepth 2 -mindepth 2 -name Makefile | sort)
|
||||
for subdir in $$SUBDIRS; do
|
||||
$(MAKE) --no-print-directory -C $$(dirname $$subdir) init
|
||||
done
|
||||
if [[ $$SUBDIRS = *[![:space:]]* ]]; then
|
||||
$(MAKE) print_head
|
||||
fi
|
||||
# Create venv if needed
|
||||
if [[ -e $(VENV_FLAG) ]]; then
|
||||
BASEPATH=$$(pwd -P)
|
||||
#
|
||||
# Create venv
|
||||
#
|
||||
if [ ! -e venv ];then
|
||||
echo -e "\033[1;33mCreating venv in $$BASEPATH...\e[0m"
|
||||
python3 -m venv $$BASEPATH/venv > /dev/null 2>&1
|
||||
else
|
||||
echo -e "\033[1;33mVirtualenv already exists in $$BASEPATH...\e[0m"
|
||||
fi
|
||||
echo
|
||||
|
||||
#
|
||||
# Install modules
|
||||
#
|
||||
echo -e "\033[1;33mInstalling modules to venv in $$BASEPATH...\e[0m"
|
||||
for req_file in $$(find -L $$BASEPATH -name requirements.txt 2> /dev/null); do
|
||||
# echo " $$req_file"
|
||||
while read req_mod; do
|
||||
if [[ $$req_mod = *[![:space:]]* ]]; then
|
||||
# req_mod is not empty
|
||||
OUT=$$($$BASEPATH/venv/bin/pip install -U $$req_mod 2>&1 )
|
||||
if [[ $$OUT =~ "Successfully installed" ]]; then
|
||||
echo -e " * \033[1;32m$$req_mod installed.\e[0m"
|
||||
elif [[ $$OUT =~ "already satisfied" ]]; then
|
||||
echo -e " * \033[1;36m$$req_mod already available.\e[0m"
|
||||
else
|
||||
echo -e " * \033[1;31m$$req_mod FAILED!\e[0m"
|
||||
#echo $$OUT
|
||||
fi
|
||||
fi
|
||||
done < $$req_file
|
||||
done
|
||||
echo
|
||||
fi
|
||||
# Start local init
|
||||
echo -e "\033[1;33mDoing localinit...\e[0m"
|
||||
$(MAKE) localinit
|
||||
|
||||
update_submodules:
|
||||
git submodule foreach "git fetch && git checkout master && git pull && git submodule init && git submodule update"
|
||||
|
||||
giti_this: print_head
|
||||
giti
|
||||
echo " Submodules:"
|
||||
git submodule --quiet foreach "echo -n ' ' && giti"
|
||||
|
||||
giti:
|
||||
git submodule --quiet foreach "[ -e Makefile ] && make --no-print-directory giti_this || :"
|
||||
|
||||
localclean:
|
||||
|
||||
clean: localclean
|
||||
if [[ ! -e $(VENV_FLAG) ]]; then
|
||||
if [[ -d $(VENV_FOLDER) ]]; then
|
||||
rm -rf $(VENV_FOLDER)
|
||||
fi
|
||||
fi
|
||||
|
||||
cleanall: clean
|
||||
for subdir in $$(find . -maxdepth 2 -mindepth 2 -name Makefile | sort); do
|
||||
$(MAKE) --no-print-directory -C $$(dirname $$subdir) cleanall
|
||||
done
|
||||
|
||||
|
||||
venv_flag:
|
||||
if [[ ! -e $(VENV_FLAG) ]]; then
|
||||
touch $(VENV_FLAG)
|
||||
if [[ -e $(GIT_FLAG) ]]; then
|
||||
git add $(VENV_FLAG)
|
||||
fi
|
||||
fi
|
||||
|
||||
print_head:
|
||||
DIRNAME=$$(basename $$(pwd))
|
||||
DIRLENGTH=$${#DIRNAME}
|
||||
echo -ne "\n\n\033[1;34m╔═"
|
||||
for i in $$(seq 1 $$DIRLENGTH); do echo -n "═"; done
|
||||
echo -e "═╗"
|
||||
echo -e "║ $$DIRNAME ║"
|
||||
echo -ne "╚═"
|
||||
for i in $$(seq 1 $$DIRLENGTH); do echo -n "═"; done
|
||||
echo -e "═╝\033[00m"
|
||||
41
__install__.py
Normal file
41
__install__.py
Normal file
@ -0,0 +1,41 @@
|
||||
#!/bin/python
|
||||
#
|
||||
import os
|
||||
import sys
|
||||
|
||||
SERVICE_FILE = """
|
||||
[Unit]
|
||||
Description=Smarthome Ambient Information Service
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
[Service]
|
||||
User=%(UID)d
|
||||
Group=%(GID)d
|
||||
ExecStart=%(MY_PATH)s/smart_brain.sh
|
||||
Type=simple
|
||||
[Install]
|
||||
WantedBy=default.target
|
||||
"""
|
||||
|
||||
|
||||
def help():
|
||||
print("Usage: prog <UID> <GID> <TARGET_PATH>")
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) == 4:
|
||||
try:
|
||||
uid = int(sys.argv[1])
|
||||
gid = int(sys.argv[2])
|
||||
except ValueError:
|
||||
help()
|
||||
else:
|
||||
if os.path.isdir(sys.argv[3]):
|
||||
with open(os.path.join(sys.argv[3], 'smart_brain.service'), "w") as fh:
|
||||
fh.write(SERVICE_FILE % {
|
||||
"MY_PATH": os.path.dirname(os.path.abspath(__file__)),
|
||||
"UID": uid,
|
||||
"GID": gid})
|
||||
else:
|
||||
help()
|
||||
else:
|
||||
help()
|
||||
@ -1,17 +0,0 @@
|
||||
.ONESHELL:
|
||||
SHELL = /usr/bin/bash
|
||||
MAKEFLAGS += --no-print-directory
|
||||
.SILENT:
|
||||
|
||||
devinit:
|
||||
if [[ ! -e config.py ]]; then
|
||||
cp config_example/config.j2 config.py
|
||||
chmod 600 config.py
|
||||
sed -i "/^DEBUG.*=.*/c\DEBUG = True" config.py
|
||||
sed -i "/^LOG_HOSTNAME.*=.*/c\LOG_HOSTNAME = \"localhost\"" config.py
|
||||
sed -i "/^LOG_LEVEL.*=.*/c\LOG_LEVEL = logging.WARNING" config.py
|
||||
sed -i 's/{{ smart_srv_brain_hostname }}/localhost/' config.py
|
||||
sed -i 's/"{{ smart_srv_brain_username }}"/None/' config.py
|
||||
sed -i 's/"{{ smart_srv_brain_password }}"/None/' config.py
|
||||
fi
|
||||
|
||||
@ -1,12 +0,0 @@
|
||||
.ONESHELL:
|
||||
SHELL = /usr/bin/bash
|
||||
MAKEFLAGS += --no-print-directory
|
||||
.SILENT:
|
||||
|
||||
COV3_CMD=venv/bin/coverage
|
||||
|
||||
|
||||
coverage:
|
||||
$(COV3_CMD) erase
|
||||
$(COV3_CMD) run -a --branch --source=devdi,smart_devices,devices,function smart_brain.py
|
||||
$(COV3_CMD) xml -o ../smart_brain_test/testresults/coverage.xml
|
||||
@ -1,13 +0,0 @@
|
||||
.ONESHELL:
|
||||
SHELL = /usr/bin/bash
|
||||
MAKEFLAGS += --no-print-directory
|
||||
.SILENT:
|
||||
|
||||
GIT_FLAG = ./.git
|
||||
VENV_FLAG = ./.venv_required
|
||||
VENV_FOLDER = ./venv
|
||||
|
||||
localhelp:
|
||||
echo "Possible local options are:"
|
||||
echo " - devinit - Initialise the application for development usage"
|
||||
echo " - coverage - Run smarthome in coverage mode"
|
||||
847
__simulation__/devices.py
Normal file
847
__simulation__/devices.py
Normal file
@ -0,0 +1,847 @@
|
||||
import colored
|
||||
import json
|
||||
import sys
|
||||
import task
|
||||
import time
|
||||
|
||||
COLOR_GUI_ACTIVE = colored.fg("light_blue")
|
||||
COLOR_GUI_PASSIVE = COLOR_GUI_ACTIVE + colored.attr("dim")
|
||||
COLOR_SHELLY = colored.fg("light_magenta")
|
||||
COLOR_POWERPLUG = colored.fg("light_cyan")
|
||||
COLOR_LIGHT_ACTIVE = colored.fg("yellow")
|
||||
COLOR_LIGHT_PASSIVE = COLOR_LIGHT_ACTIVE + colored.attr("dim")
|
||||
COLOR_MOTION_SENSOR = colored.fg("dark_orange_3b")
|
||||
COLOR_RADIATOR_VALVE = colored.fg("red")
|
||||
COLOR_REMOTE = colored.fg("green")
|
||||
|
||||
|
||||
def payload_filter(payload):
|
||||
try:
|
||||
return json.loads(payload)
|
||||
except json.decoder.JSONDecodeError:
|
||||
return payload.decode("utf-8")
|
||||
|
||||
|
||||
def command_int_value(value):
|
||||
try:
|
||||
return int(value)
|
||||
except TypeError:
|
||||
print("You need to give a integer parameter not '%s'" % str(value))
|
||||
|
||||
|
||||
def command_float_value(value):
|
||||
try:
|
||||
return float(value)
|
||||
except TypeError:
|
||||
print("You need to give a integer parameter not '%s'" % str(value))
|
||||
|
||||
|
||||
def devicename(topic):
|
||||
return " - ".join(topic.split('/')[1:])
|
||||
|
||||
|
||||
def percent_bar(value):
|
||||
rv = ""
|
||||
for i in range(0, 10):
|
||||
rv += u"\u25ac" if (value - 5) > 10*i else u"\u25ad"
|
||||
return rv
|
||||
|
||||
|
||||
def print_light(color, state, topic, description, led=False):
|
||||
if led is True:
|
||||
if state is True:
|
||||
icon = colored.fg('green') + "\u2b24" + color
|
||||
else:
|
||||
icon = colored.fg('light_gray') + "\u2b24" + color
|
||||
else:
|
||||
icon = u'\u2b24' if state is True else u'\u25ef'
|
||||
print(color + 10 * ' ' + icon + 9 * ' ' + devicename(topic), description + colored.attr("reset"))
|
||||
|
||||
|
||||
def print_switch(color, state, topic, description):
|
||||
icon = u'\u25a0' if state is True else u'\u25a1'
|
||||
print(color + 10 * ' ' + icon + 9 * ' ' + devicename(topic), description + colored.attr("reset"))
|
||||
|
||||
|
||||
def print_percent(color, prefix, perc_value, value_str, topic, description):
|
||||
if len(prefix) > 1 or len(value_str) > 7:
|
||||
raise ValueError("Length of prefix (%d) > 1 or length of value_str (%d) > 7" % (len(prefix), len(value_str)))
|
||||
print(color + prefix + percent_bar(perc_value), value_str + (8 - len(value_str)) * ' ' + devicename(topic), description + colored.attr("reset"))
|
||||
|
||||
|
||||
class base(object):
|
||||
AUTOSEND = True
|
||||
COMMANDS = []
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
self.mqtt_client = mqtt_client
|
||||
self.topic = topic
|
||||
#
|
||||
self.data = {}
|
||||
self.callbacks = {}
|
||||
self.names = {}
|
||||
self.commands = self.COMMANDS[:]
|
||||
#
|
||||
self.mqtt_client.add_callback(self.topic, self.__rx__)
|
||||
self.mqtt_client.add_callback(self.topic + '/#', self.__rx__)
|
||||
|
||||
def add_callback(self, key, callback, value):
|
||||
if self.callbacks.get(key) is None:
|
||||
self.callbacks[key] = []
|
||||
self.callbacks[key].append((callback, value))
|
||||
|
||||
def add_channel_name(self, key, name):
|
||||
self.names[key] = name
|
||||
|
||||
def capabilities(self):
|
||||
return self.commands
|
||||
|
||||
def store_data(self, *args, **kwargs):
|
||||
keys_changed = []
|
||||
for key in kwargs:
|
||||
if kwargs[key] is not None and kwargs[key] != self.data.get(key):
|
||||
keys_changed.append(key)
|
||||
self.data[key] = kwargs[key]
|
||||
for callback, value in self.callbacks.get(key, [(None, None)]):
|
||||
if callback is not None and (value is None or value == kwargs[key]):
|
||||
callback(self, key, kwargs[key])
|
||||
if self.AUTOSEND and len(keys_changed) > 0:
|
||||
self.__tx__(keys_changed)
|
||||
|
||||
def __tx__(self, keys_changed):
|
||||
self.mqtt_client.send(self.topic, json.dumps(self.data))
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
print("%s: __rx__ not handled!" % self.__class__.__name__)
|
||||
|
||||
|
||||
class shelly(base):
|
||||
KEY_OUTPUT_0 = "relay/0"
|
||||
KEY_OUTPUT_1 = "relay/1"
|
||||
KEY_INPUT_0 = "input/0"
|
||||
KEY_INPUT_1 = "input/1"
|
||||
KEY_LONGPUSH_0 = "longpush/0"
|
||||
KEY_LONGPUSH_1 = "longpush/1"
|
||||
#
|
||||
INPUT_FUNC_OUT1_FOLLOW = "out1_follow"
|
||||
INPUT_FUNC_OUT1_TRIGGER = "out1_trigger"
|
||||
INPUT_FUNC_OUT2_FOLLOW = "out2_follow"
|
||||
INPUT_FUNC_OUT2_TRIGGER = "out2_trigger"
|
||||
#
|
||||
COMMANDS = [
|
||||
"get_relay_0", "toggle_relay_0",
|
||||
"get_relay_1", "toggle_relay_1",
|
||||
"get_input_0", "toggle_input_0",
|
||||
"get_input_1", "toggle_input_1",
|
||||
"trigger_long_input_0", "trigger_long_input_1",
|
||||
]
|
||||
|
||||
def __init__(self, mqtt_client, topic, input_0_func=None, input_1_func=None, output_0_auto_off=None):
|
||||
super().__init__(mqtt_client, topic)
|
||||
#
|
||||
self.store_data(**{self.KEY_OUTPUT_0: "off", self.KEY_OUTPUT_1: "off", self.KEY_INPUT_0: "off", self.KEY_INPUT_1: "off"})
|
||||
self.__input_0_func = input_0_func
|
||||
self.__input_1_func = input_1_func
|
||||
self.__output_0_auto_off__ = output_0_auto_off
|
||||
if self.__output_0_auto_off__ is not None:
|
||||
self.__delayed_off__ = task.delayed(float(self.__output_0_auto_off__), self.__auto_off__, self.KEY_OUTPUT_0)
|
||||
#
|
||||
self.add_callback(self.KEY_OUTPUT_0, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_OUTPUT_0, self.__start_auto_off__, "on")
|
||||
self.add_callback(self.KEY_OUTPUT_0, self.__stop_auto_off__, "off")
|
||||
self.add_callback(self.KEY_OUTPUT_1, self.print_formatted, None)
|
||||
#
|
||||
self.add_callback(self.KEY_INPUT_0, self.__input_function__, None)
|
||||
self.add_callback(self.KEY_INPUT_1, self.__input_function__, None)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
value = payload_filter(message.payload)
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith("/command"):
|
||||
key = '/'.join(message.topic.split('/')[-3:-1])
|
||||
if value == 'toggle':
|
||||
self.__toggle_data__(key)
|
||||
else:
|
||||
self.__set_data__(key, value)
|
||||
|
||||
def __tx__(self, keys_changed):
|
||||
for key in keys_changed:
|
||||
self.mqtt_client.send(self.topic + '/' + key, self.data.get(key))
|
||||
|
||||
def __input_function__(self, device, key, data):
|
||||
if key == self.KEY_INPUT_0:
|
||||
func = self.__input_0_func
|
||||
elif key == self.KEY_INPUT_1:
|
||||
func = self.__input_1_func
|
||||
else:
|
||||
func = None
|
||||
if func == self.INPUT_FUNC_OUT1_FOLLOW:
|
||||
self.__set_data__(self.KEY_OUTPUT_0, data)
|
||||
elif func == self.INPUT_FUNC_OUT1_TRIGGER:
|
||||
self.__toggle_data__(self.KEY_OUTPUT_0)
|
||||
elif func == self.INPUT_FUNC_OUT2_FOLLOW:
|
||||
self.__set_data__(self.KEY_OUTPUT_1, data)
|
||||
elif func == self.INPUT_FUNC_OUT2_TRIGGER:
|
||||
self.__toggle_data__(self.KEY_OUTPUT_1)
|
||||
|
||||
def __start_auto_off__(self, device, key, data):
|
||||
self.__stop_auto_off__(device, key, data)
|
||||
if self.__output_0_auto_off__ is not None:
|
||||
self.__delayed_off__.run()
|
||||
|
||||
def __stop_auto_off__(self, device, key, data):
|
||||
if self.__output_0_auto_off__ is not None:
|
||||
if not self.__delayed_off__._stopped:
|
||||
self.__delayed_off__.stop()
|
||||
|
||||
def __auto_off__(self, key):
|
||||
if key == self.KEY_OUTPUT_0:
|
||||
self.__set_data__(key, 'off')
|
||||
|
||||
def __set_data__(self, key, value):
|
||||
if value in ["on", "off"]:
|
||||
self.store_data(**{key: value})
|
||||
else:
|
||||
print("Wrong value (%s)!" % repr(value))
|
||||
|
||||
def __toggle_data__(self, key):
|
||||
if key in self.data:
|
||||
self.__set_data__(key, 'on' if self.data.get(key) == 'off' else 'off')
|
||||
|
||||
def command(self, command):
|
||||
if command in self.COMMANDS:
|
||||
if command == self.COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_0, self.data.get(self.KEY_OUTPUT_0))
|
||||
elif command == self.COMMANDS[1]:
|
||||
self.__toggle_data__(self.KEY_OUTPUT_0)
|
||||
elif command == self.COMMANDS[2]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_1, self.data.get(self.KEY_OUTPUT_1))
|
||||
elif command == self.COMMANDS[3]:
|
||||
self.__toggle_data__(self.KEY_OUTPUT_1)
|
||||
elif command == self.COMMANDS[4]:
|
||||
self.print_formatted(self, self.KEY_INPUT_0, self.data.get(self.KEY_INPUT_0))
|
||||
elif command == self.COMMANDS[5]:
|
||||
self.__toggle_data__(self.KEY_INPUT_0)
|
||||
elif command == self.COMMANDS[6]:
|
||||
self.print_formatted(self, self.KEY_INPUT_1, self.data.get(self.KEY_INPUT_1))
|
||||
elif command == self.COMMANDS[7]:
|
||||
self.__toggle_data__(self.KEY_INPUT_1)
|
||||
elif command == self.COMMANDS[8]:
|
||||
self.__toggle_data__(self.KEY_INPUT_0)
|
||||
time.sleep(0.4)
|
||||
self.__set_data__(self.KEY_LONGPUSH_0, 'on')
|
||||
time.sleep(0.1)
|
||||
self.__set_data__(self.KEY_LONGPUSH_0, 'off')
|
||||
elif command == self.COMMANDS[9]:
|
||||
self.__toggle_data__(self.KEY_INPUT_1)
|
||||
time.sleep(0.4)
|
||||
self.__set_data__(self.KEY_LONGPUSH_1, 'on')
|
||||
time.sleep(0.1)
|
||||
self.__set_data__(self.KEY_LONGPUSH_1, 'off')
|
||||
else:
|
||||
print("%s: not yet implemented!" % command)
|
||||
else:
|
||||
print("Unknown command!")
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
info = (" - %ds" % self.__output_0_auto_off__) if self.__output_0_auto_off__ is not None and value == "on" else ""
|
||||
channel = "(%s%s)" % (self.names.get(key, key), info)
|
||||
print_light(COLOR_SHELLY, value == "on", self.topic, channel)
|
||||
|
||||
|
||||
class my_powerplug(base):
|
||||
KEY_OUTPUT_0 = "0"
|
||||
KEY_OUTPUT_1 = "1"
|
||||
KEY_OUTPUT_2 = "2"
|
||||
KEY_OUTPUT_3 = "3"
|
||||
COMMANDS = [
|
||||
"get_output_0", "toggle_output_0",
|
||||
"get_output_1", "toggle_output_1",
|
||||
"get_output_2", "toggle_output_2",
|
||||
"get_output_3", "toggle_output_3",
|
||||
]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
#
|
||||
for i in range(0, 4):
|
||||
self.data[str(i)] = False
|
||||
self.add_callback(str(i), self.print_formatted, None)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
if message.topic.startswith(self.topic + '/output/') and message.topic.endswith('/set'):
|
||||
try:
|
||||
channels = [int(message.topic.split('/')[-2]) - 1]
|
||||
except ValueError:
|
||||
channels = range(0, 4)
|
||||
for channel in channels:
|
||||
payload = payload_filter(message.payload)
|
||||
if payload == "toggle":
|
||||
payload = not self.data.get(str(channel))
|
||||
self.store_data(**{str(channel): payload})
|
||||
|
||||
def __tx__(self, keys_changed):
|
||||
for key in keys_changed:
|
||||
self.mqtt_client.send(self.topic + "/output/" + str(int(key) + 1), json.dumps(self.data.get(key)))
|
||||
|
||||
def command(self, command):
|
||||
if command in self.COMMANDS:
|
||||
if command == self.COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_0, self.data.get(self.KEY_OUTPUT_0))
|
||||
elif command == self.COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: not self.data.get(self.KEY_OUTPUT_0)})
|
||||
elif command == self.COMMANDS[2]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_1, self.data.get(self.KEY_OUTPUT_1))
|
||||
elif command == self.COMMANDS[3]:
|
||||
self.store_data(**{self.KEY_OUTPUT_1: not self.data.get(self.KEY_OUTPUT_1)})
|
||||
elif command == self.COMMANDS[4]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_2, self.data.get(self.KEY_OUTPUT_2))
|
||||
elif command == self.COMMANDS[5]:
|
||||
self.store_data(**{self.KEY_OUTPUT_2: not self.data.get(self.KEY_OUTPUT_2)})
|
||||
elif command == self.COMMANDS[6]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_3, self.data.get(self.KEY_OUTPUT_3))
|
||||
elif command == self.COMMANDS[7]:
|
||||
self.store_data(**{self.KEY_OUTPUT_3: not self.data.get(self.KEY_OUTPUT_3)})
|
||||
else:
|
||||
print("%s: not yet implemented!" % command)
|
||||
else:
|
||||
print("Unknown command!")
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
print_light(COLOR_POWERPLUG, value, self.topic, "(%s)" % self.names.get(key, "Channel %d" % (int(key) + 1)))
|
||||
|
||||
|
||||
class silvercrest_powerplug(base):
|
||||
KEY_OUTPUT_0 = "state"
|
||||
#
|
||||
COMMANDS = [
|
||||
"get_state", "set_state", "unset_state",
|
||||
]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.add_callback(self.KEY_OUTPUT_0, self.print_formatted, None)
|
||||
#
|
||||
self.store_data(**{self.KEY_OUTPUT_0: "off"})
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
if message.topic == self.topic + '/set':
|
||||
STATES = ["on", "off", "toggle"]
|
||||
#
|
||||
state = json.loads(message.payload).get('state').lower()
|
||||
if state in STATES:
|
||||
if state == STATES[0]:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: 'on'})
|
||||
elif state == STATES[1]:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: 'off'})
|
||||
else:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: "off" if self.data.get(self.KEY_OUTPUT_0) == "on" else "on"})
|
||||
|
||||
def command(self, command):
|
||||
if command in self.COMMANDS:
|
||||
if command == self.COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_OUTPUT_0, self.data.get(self.KEY_OUTPUT_0))
|
||||
elif command == self.COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: 'on'})
|
||||
elif command == self.COMMANDS[2]:
|
||||
self.store_data(**{self.KEY_OUTPUT_0: 'off'})
|
||||
else:
|
||||
print("%s: not yet implemented!" % command)
|
||||
else:
|
||||
print("Unknown command!")
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
print_light(COLOR_POWERPLUG, value == "on", self.topic, "(%s)" % self.names.get(key, key))
|
||||
|
||||
|
||||
class silvercrest_motion_sensor(base):
|
||||
KEY_OCCUPANCY = "occupancy"
|
||||
COMMANDS = ['motion']
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.data[self.KEY_OCCUPANCY] = False
|
||||
self.add_callback(self.KEY_OCCUPANCY, self.print_formatted, None)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
pass
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
else:
|
||||
value = json.loads(value)
|
||||
if command == self.COMMANDS[0]:
|
||||
self.store_data(**{self.KEY_OCCUPANCY: True})
|
||||
time.sleep(value or 10)
|
||||
self.store_data(**{self.KEY_OCCUPANCY: False})
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
print_light(COLOR_MOTION_SENSOR, value, self.topic, "")
|
||||
|
||||
|
||||
class tradfri_light(base):
|
||||
KEY_STATE = "state"
|
||||
KEY_BRIGHTNESS = "brightness"
|
||||
KEY_COLOR_TEMP = "color_temp"
|
||||
KEY_BRIGHTNESS_MOVE = "brightness_move"
|
||||
#
|
||||
STATE_COMMANDS = ("get_state", "toggle_state", )
|
||||
BRIGHTNESS_COMMANDS = ("get_brightness", "set_brightness",)
|
||||
COLOR_TEMP_COMMANDS = ("get_color_temp", "set_color_temp",)
|
||||
|
||||
def __init__(self, mqtt_client, topic, enable_state=True, enable_brightness=False, enable_color_temp=False, send_on_power_on=True):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.send_on_power_on = send_on_power_on
|
||||
self.add_callback(self.KEY_STATE, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_BRIGHTNESS, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_COLOR_TEMP, self.print_formatted, None)
|
||||
#
|
||||
self.commands = []
|
||||
if enable_state:
|
||||
self.commands.extend(self.STATE_COMMANDS)
|
||||
if enable_brightness:
|
||||
self.commands.extend(self.BRIGHTNESS_COMMANDS)
|
||||
if enable_color_temp:
|
||||
self.commands.extend(self.COLOR_TEMP_COMMANDS)
|
||||
self.__init_data__(enable_state, enable_brightness, enable_color_temp)
|
||||
|
||||
def __init_data__(self, enable_state, enable_brightness, enable_color_temp):
|
||||
data = {}
|
||||
if enable_state:
|
||||
data[self.KEY_STATE] = 'off'
|
||||
self.commands.extend(self.STATE_COMMANDS)
|
||||
if enable_brightness:
|
||||
data[self.KEY_BRIGHTNESS] = 128
|
||||
self.brightnes_move = (0, time.time())
|
||||
self.commands.extend(self.BRIGHTNESS_COMMANDS)
|
||||
if enable_color_temp:
|
||||
data[self.KEY_COLOR_TEMP] = 352
|
||||
self.commands.extend(self.COLOR_TEMP_COMMANDS)
|
||||
self.store_data(**data)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
data = json.loads(message.payload)
|
||||
if self.data.get(self.KEY_STATE) == 'on' or data.get(self.KEY_STATE) in ['on', 'toggle']:
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith('/set'):
|
||||
for targetkey in data:
|
||||
value = data[targetkey]
|
||||
if targetkey in self.data.keys():
|
||||
if targetkey == self.KEY_STATE and value == "toggle":
|
||||
value = "on" if self.data.get(self.KEY_STATE) == "off" else "off"
|
||||
self.store_data(**{targetkey: value})
|
||||
else:
|
||||
if targetkey == self.KEY_BRIGHTNESS_MOVE:
|
||||
new_value = self.data.get(self.KEY_BRIGHTNESS) + (time.time() - self.brightnes_move[1]) * self.brightnes_move[0]
|
||||
if new_value < 0:
|
||||
new_value = 0
|
||||
if new_value > 255:
|
||||
new_value = 255
|
||||
self.store_data(**{self.KEY_BRIGHTNESS: int(new_value)})
|
||||
self.brightnes_move = (value, time.time())
|
||||
else:
|
||||
print("%s: UNKNOWN KEY %s" % (message.topic, targetkey))
|
||||
elif message.topic == self.topic + '/get':
|
||||
self.__tx__(None)
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
if command in self.capabilities():
|
||||
if command == self.STATE_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_STATE, self.data.get(self.KEY_STATE))
|
||||
elif command == self.STATE_COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_STATE: 'off' if self.data.get(self.KEY_STATE) == 'on' else 'on'})
|
||||
elif command == self.BRIGHTNESS_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_BRIGHTNESS, self.data.get(self.KEY_BRIGHTNESS))
|
||||
elif command == self.BRIGHTNESS_COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_BRIGHTNESS: command_int_value(value)})
|
||||
elif command == self.COLOR_TEMP_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_COLOR_TEMP, self.data.get(self.KEY_COLOR_TEMP))
|
||||
elif command == self.COLOR_TEMP_COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_COLOR_TEMP: command_int_value(value)})
|
||||
else:
|
||||
print("%s: not yet implemented!" % command)
|
||||
else:
|
||||
print("Unknown command!")
|
||||
|
||||
def power_off(self, device, key, value):
|
||||
self.data[self.KEY_STATE] = 'off'
|
||||
self.print_formatted(self, self.KEY_STATE, 'off')
|
||||
|
||||
def power_on(self, device, key, value):
|
||||
if self.send_on_power_on:
|
||||
self.store_data(**{self.KEY_STATE: 'on'})
|
||||
else:
|
||||
self.data[self.KEY_STATE] = 'on'
|
||||
self.print_formatted(self, self.KEY_STATE, 'on')
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
color = COLOR_LIGHT_ACTIVE
|
||||
if key == self.KEY_STATE:
|
||||
print_light(COLOR_LIGHT_ACTIVE, value == "on", self.topic, "")
|
||||
self.print_formatted(device, self.KEY_BRIGHTNESS, self.data.get(self.KEY_BRIGHTNESS))
|
||||
self.print_formatted(device, self.KEY_COLOR_TEMP, self.data.get(self.KEY_COLOR_TEMP))
|
||||
elif key in [self.KEY_BRIGHTNESS, self.KEY_COLOR_TEMP]:
|
||||
perc_value = round(value * 100 / 256, 0) if key == self.KEY_BRIGHTNESS else round((value - 250) * 100 / 204, 0)
|
||||
print_percent(
|
||||
COLOR_LIGHT_PASSIVE if self.data.get(self.KEY_STATE) != "on" else COLOR_LIGHT_ACTIVE,
|
||||
'B' if key == gui_light.KEY_BRIGHTNESS else 'C',
|
||||
perc_value,
|
||||
"%3d%%" % perc_value,
|
||||
self.topic,
|
||||
""
|
||||
)
|
||||
|
||||
|
||||
class gui_light(tradfri_light):
|
||||
AUTOSEND = False
|
||||
#
|
||||
KEY_ENABLE = "enable"
|
||||
KEY_TIMER = "timer"
|
||||
KEY_LED_X = "led%d"
|
||||
|
||||
def __init__(self, mqtt_client, topic, enable_state=True, enable_brightness=False, enable_color_temp=False):
|
||||
super().__init__(mqtt_client, topic, enable_state, enable_brightness, enable_color_temp)
|
||||
self.add_callback(self.KEY_ENABLE, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_TIMER, self.print_formatted, None)
|
||||
for i in range(0, 10):
|
||||
self.add_callback(self.KEY_LED_X % i, self.print_formatted, None)
|
||||
self.led_names = {}
|
||||
#
|
||||
self.maxvalue = None
|
||||
self.last_printed = None
|
||||
|
||||
def __init_data__(self, enable_state, enable_brightness, enable_color_temp):
|
||||
data = {}
|
||||
data[self.KEY_ENABLE] = False
|
||||
if enable_state:
|
||||
data[self.KEY_STATE] = False
|
||||
if enable_brightness:
|
||||
data[self.KEY_BRIGHTNESS] = 50
|
||||
if enable_color_temp:
|
||||
data[self.KEY_COLOR_TEMP] = 5
|
||||
data[self.KEY_TIMER] = '-'
|
||||
for i in range(0, 10):
|
||||
data[self.KEY_LED_X % i] = False
|
||||
self.store_data(**data)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
value = payload_filter(message.payload)
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith('/set'):
|
||||
targetkey = message.topic.split('/')[-2]
|
||||
if targetkey in self.data.keys():
|
||||
self.store_data(**{targetkey: value})
|
||||
else:
|
||||
print("Unknown key %s in %s::%s" % (targetkey, message.topic, self.__class__.__name__))
|
||||
elif message.topic == self.topic + '/get':
|
||||
self.__tx__(None)
|
||||
|
||||
def send(self, key, data):
|
||||
if data is not None:
|
||||
topic = self.topic + '/' + key
|
||||
self.mqtt_client.send(topic, json.dumps(data))
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
if command in self.capabilities():
|
||||
if command == self.STATE_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_STATE, self.data.get(self.KEY_STATE))
|
||||
elif command == self.STATE_COMMANDS[1]:
|
||||
self.send(self.KEY_STATE, not self.data.get(self.KEY_STATE))
|
||||
elif command == self.BRIGHTNESS_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_BRIGHTNESS, self.data.get(self.KEY_BRIGHTNESS))
|
||||
elif command == self.BRIGHTNESS_COMMANDS[1]:
|
||||
self.send(self.KEY_BRIGHTNESS, command_int_value(value))
|
||||
elif command == self.COLOR_TEMP_COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_COLOR_TEMP, self.data.get(self.KEY_COLOR_TEMP))
|
||||
elif command == self.COLOR_TEMP_COMMANDS[1]:
|
||||
self.send(self.KEY_COLOR_TEMP, command_int_value(value))
|
||||
else:
|
||||
print("%s: not yet implemented!" % command)
|
||||
else:
|
||||
print("Unknown command!")
|
||||
|
||||
def add_led_name(self, key, name):
|
||||
self.led_names[key] = name
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
if value is not None:
|
||||
device = " - ".join(self.topic.split('/')[1:])
|
||||
if key == self.KEY_STATE:
|
||||
print_switch(COLOR_GUI_ACTIVE, value, self.topic, "")
|
||||
elif key == self.KEY_ENABLE:
|
||||
self.print_formatted(device, self.KEY_BRIGHTNESS, self.data.get(self.KEY_BRIGHTNESS))
|
||||
self.print_formatted(device, self.KEY_COLOR_TEMP, self.data.get(self.KEY_COLOR_TEMP))
|
||||
elif key in [self.KEY_BRIGHTNESS, self.KEY_COLOR_TEMP]:
|
||||
perc_value = round(value * 10 if key == self.KEY_COLOR_TEMP else value, 0)
|
||||
print_percent(
|
||||
COLOR_GUI_PASSIVE if not self.data.get(self.KEY_ENABLE, False) else COLOR_GUI_ACTIVE,
|
||||
'B' if key == self.KEY_BRIGHTNESS else 'C',
|
||||
perc_value,
|
||||
"%3d%%" % perc_value,
|
||||
self.topic,
|
||||
""
|
||||
)
|
||||
elif key == self.KEY_TIMER:
|
||||
if isinstance(value, (int, float, complex)) and not isinstance(value, bool):
|
||||
if self.maxvalue is None:
|
||||
self.maxvalue = value
|
||||
disp_value = value
|
||||
perc = disp_value / self.maxvalue * 100
|
||||
else:
|
||||
disp_value = 0
|
||||
perc = 0
|
||||
self.maxvalue = None
|
||||
self.last_printed = None
|
||||
if self.last_printed is None or abs(self.last_printed - perc) >= 4.95:
|
||||
print_percent(COLOR_GUI_ACTIVE, 't', perc, '%3d%%' % perc, self.topic, '(%.1f)' % disp_value)
|
||||
self.last_printed = perc
|
||||
elif key.startswith(self.KEY_LED_X[:-2]):
|
||||
print_light(COLOR_GUI_ACTIVE, value, self.topic, '(%s)' % self.led_names.get(key, key), True)
|
||||
|
||||
|
||||
class tradfri_button(base):
|
||||
KEY_ACTION = "action"
|
||||
#
|
||||
ACTION_TOGGLE = "toggle"
|
||||
ACTION_BRIGHTNESS_UP = "brightness_up_click"
|
||||
ACTION_BRIGHTNESS_DOWN = "brightness_down_click"
|
||||
ACTION_RIGHT = "arrow_right_click"
|
||||
ACTION_LEFT = "arrow_left_click"
|
||||
ACTION_BRIGHTNESS_UP_LONG = "brightness_up_hold"
|
||||
ACTION_BRIGHTNESS_DOWN_LONG = "brightness_down_hold"
|
||||
ACTION_RIGHT_LONG = "arrow_right_hold"
|
||||
ACTION_LEFT_LONG = "arrow_left_hold"
|
||||
#
|
||||
COMMANDS = [ACTION_TOGGLE, ACTION_LEFT, ACTION_RIGHT, ACTION_BRIGHTNESS_UP, ACTION_BRIGHTNESS_DOWN,
|
||||
ACTION_LEFT_LONG, ACTION_RIGHT_LONG, ACTION_BRIGHTNESS_UP_LONG, ACTION_BRIGHTNESS_DOWN_LONG]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
pass
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
else:
|
||||
value = json.loads(value)
|
||||
if command in self.capabilities():
|
||||
action = self.COMMANDS[self.COMMANDS.index(command)]
|
||||
if self.COMMANDS.index(command) <= 4:
|
||||
self.mqtt_client.send(self.topic, json.dumps({self.KEY_ACTION: action}))
|
||||
elif self.COMMANDS.index(command) <= 8:
|
||||
self.mqtt_client.send(self.topic, json.dumps({self.KEY_ACTION: action}))
|
||||
time.sleep(value or 0.5)
|
||||
action = '_'.join(action.split('_')[:-1] + ['release'])
|
||||
self.mqtt_client.send(self.topic, json.dumps({self.KEY_ACTION: action}))
|
||||
|
||||
|
||||
class gui_led_array(base):
|
||||
AUTOSEND = False
|
||||
#
|
||||
KEY_LED_0 = "led0"
|
||||
KEY_LED_1 = "led1"
|
||||
KEY_LED_2 = "led2"
|
||||
KEY_LED_3 = "led3"
|
||||
KEY_LED_4 = "led4"
|
||||
KEY_LED_5 = "led5"
|
||||
KEY_LED_6 = "led6"
|
||||
KEY_LED_7 = "led7"
|
||||
KEY_LED_8 = "led8"
|
||||
KEY_LED_9 = "led9"
|
||||
|
||||
def __init__(self, mqtt_client, topic, ):
|
||||
super().__init__(mqtt_client, topic)
|
||||
for i in range(0, 10):
|
||||
key = getattr(self, "KEY_LED_%d" % i)
|
||||
self.data[key] = False
|
||||
self.add_callback(key, self.print_formatted, None)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
value = payload_filter(message.payload)
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith('/set'):
|
||||
targetkey = message.topic.split('/')[-2]
|
||||
if targetkey in self.data.keys():
|
||||
self.store_data(**{targetkey: value})
|
||||
else:
|
||||
print("Unknown key %s in %s" % (targetkey, self.__class__.__name__))
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
print_light(COLOR_GUI_ACTIVE, value, self.topic, '(%s)' % self.names.get(key, key), True)
|
||||
|
||||
|
||||
class remote(base):
|
||||
def __rx__(self, client, userdata, message):
|
||||
if message.topic == self.topic + "/VOLUP":
|
||||
if payload_filter(message.payload):
|
||||
icon = u'\u1403'
|
||||
else:
|
||||
icon = u'\u25a1'
|
||||
elif message.topic == self.topic + "/VOLDOWN":
|
||||
if payload_filter(message.payload):
|
||||
icon = u'\u1401'
|
||||
else:
|
||||
icon = u'\u25a1'
|
||||
else:
|
||||
return
|
||||
devicename = ' - '.join(self.topic.split('/')[1:-1])
|
||||
print(COLOR_REMOTE + 10 * ' ' + icon + 6 * ' ' + devicename + colored.attr("reset"))
|
||||
|
||||
|
||||
class brennenstuhl_radiator_valve(base):
|
||||
TEMP_RANGE = [10, 30]
|
||||
#
|
||||
KEY_TEMPERATURE_SETPOINT = "current_heating_setpoint"
|
||||
KEY_TEMPERATURE = "local_temperature"
|
||||
#
|
||||
COMMANDS = [
|
||||
"get_temperature_setpoint", "set_temperature_setpoint",
|
||||
]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.store_data(**{
|
||||
self.KEY_TEMPERATURE_SETPOINT: 20,
|
||||
self.KEY_TEMPERATURE: 20.7,
|
||||
})
|
||||
self.add_callback(self.KEY_TEMPERATURE_SETPOINT, self.print_formatted, None)
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith("/set"):
|
||||
payload = payload_filter(message.payload)
|
||||
self.store_data(**payload)
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
if command in self.COMMANDS:
|
||||
if command == self.COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_TEMPERATURE_SETPOINT, self.data.get(self.KEY_TEMPERATURE_SETPOINT))
|
||||
elif command == self.COMMANDS[1]:
|
||||
self.store_data(**{self.KEY_TEMPERATURE_SETPOINT: command_float_value(value)})
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
devicename = ' - '.join(self.topic.split('/')[1:])
|
||||
if key == self.KEY_TEMPERATURE_SETPOINT:
|
||||
perc = 100 * (value - self.TEMP_RANGE[0]) / (self.TEMP_RANGE[1] - self.TEMP_RANGE[0])
|
||||
perc = 100 if perc > 100 else perc
|
||||
perc = 0 if perc < 0 else perc
|
||||
print_percent(COLOR_RADIATOR_VALVE, '\u03d1', perc, "%4.1f°C" % value, self.topic, "")
|
||||
|
||||
|
||||
class gui_radiator_valve(base):
|
||||
AUTOSEND = False
|
||||
#
|
||||
TEMP_RANGE = [10, 30]
|
||||
#
|
||||
KEY_TIMER = "timer"
|
||||
KEY_TEMPERATURE = "temperature"
|
||||
KEY_SETPOINT_TEMP = "setpoint_temp"
|
||||
KEY_SETPOINT_TO_DEFAULT = "setpoint_to_default"
|
||||
KEY_BOOST = 'boost'
|
||||
KEY_AWAY = "away"
|
||||
KEY_SUMMER = "summer"
|
||||
KEY_ENABLE = "enable"
|
||||
#
|
||||
COMMANDS = [
|
||||
"get_temperature",
|
||||
"get_temperature_setpoint", "set_temperature_setpoint",
|
||||
"trigger_boost", "trigger_setpoint_to_default",
|
||||
"toggle_away", "toggle_summer",
|
||||
]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.add_callback(self.KEY_SETPOINT_TEMP, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_TIMER, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_AWAY, self.print_formatted, None)
|
||||
self.add_callback(self.KEY_SUMMER, self.print_formatted, None)
|
||||
#
|
||||
self.store_data(**{
|
||||
self.KEY_TEMPERATURE: 20.7,
|
||||
self.KEY_SETPOINT_TEMP: 20,
|
||||
self.KEY_TIMER: 0,
|
||||
self.KEY_AWAY: False,
|
||||
self.KEY_SUMMER: False,
|
||||
self.KEY_ENABLE: True
|
||||
})
|
||||
|
||||
def __rx__(self, client, userdata, message):
|
||||
value = payload_filter(message.payload)
|
||||
if message.topic.startswith(self.topic) and message.topic.endswith('/set'):
|
||||
targetkey = message.topic.split('/')[-2]
|
||||
if targetkey in self.data.keys():
|
||||
self.store_data(**{targetkey: value})
|
||||
else:
|
||||
print("Unknown key %s in %s::%s" % (targetkey, message.topic, self.__class__.__name__))
|
||||
elif message.topic == self.topic + '/get':
|
||||
self.__tx__(None)
|
||||
|
||||
def send(self, key, data):
|
||||
if data is not None:
|
||||
topic = self.topic + '/' + key
|
||||
self.mqtt_client.send(topic, json.dumps(data))
|
||||
|
||||
def command(self, command):
|
||||
try:
|
||||
command, value = command.split(' ')
|
||||
except ValueError:
|
||||
value = None
|
||||
if command in self.COMMANDS:
|
||||
if command == self.COMMANDS[0]:
|
||||
self.print_formatted(self, self.KEY_TEMPERATURE, self.data.get(self.KEY_TEMPERATURE))
|
||||
elif command == self.COMMANDS[1]:
|
||||
self.print_formatted(self, self.KEY_SETPOINT_TEMP, self.data.get(self.KEY_SETPOINT_TEMP))
|
||||
elif command == self.COMMANDS[2]:
|
||||
self.send(self.KEY_SETPOINT_TEMP, command_float_value(value))
|
||||
elif command == self.COMMANDS[3]:
|
||||
self.send(self.KEY_BOOST, True)
|
||||
elif command == self.COMMANDS[4]:
|
||||
self.send(self.KEY_SETPOINT_TO_DEFAULT, True)
|
||||
elif command == self.COMMANDS[5]:
|
||||
self.send(self.KEY_AWAY, not self.data.get(self.KEY_AWAY))
|
||||
elif command == self.COMMANDS[6]:
|
||||
self.send(self.KEY_SUMMER, not self.data.get(self.KEY_SUMMER))
|
||||
|
||||
def print_formatted(self, device, key, value):
|
||||
devicename = ' - '.join(self.topic.split('/')[1:])
|
||||
if key == self.KEY_TIMER:
|
||||
try:
|
||||
perc = 100 * value / 60
|
||||
except TypeError:
|
||||
value = 0
|
||||
perc = 0
|
||||
print_percent(COLOR_GUI_ACTIVE, 'T', perc, "%4.1fmin" % value, self.topic, "(Timer)")
|
||||
elif key == self.KEY_TEMPERATURE:
|
||||
perc = 100 * (value - self.TEMP_RANGE[0]) / (self.TEMP_RANGE[1] - self.TEMP_RANGE[0])
|
||||
perc = 100 if perc > 100 else perc
|
||||
perc = 0 if perc < 0 else perc
|
||||
print_percent(COLOR_GUI_ACTIVE, '\u03d1', perc, "%4.1f°C" % value, self.topic, "(Temperature)")
|
||||
elif key == self.KEY_SETPOINT_TEMP:
|
||||
perc = 100 * (value - self.TEMP_RANGE[0]) / (self.TEMP_RANGE[1] - self.TEMP_RANGE[0])
|
||||
perc = 100 if perc > 100 else perc
|
||||
perc = 0 if perc < 0 else perc
|
||||
print_percent(COLOR_GUI_ACTIVE if self.data.get(self.KEY_ENABLE) else COLOR_GUI_PASSIVE,
|
||||
'\u03d1', perc, "%4.1f°C" % value, self.topic, "(Setpoint)")
|
||||
elif key == self.KEY_AWAY:
|
||||
print_switch(COLOR_GUI_ACTIVE, value, self.topic, "(Away Mode)")
|
||||
elif key == self.KEY_SUMMER:
|
||||
print_switch(COLOR_GUI_ACTIVE, value, self.topic, "(Summer Mode)")
|
||||
221
__simulation__/rooms.py
Normal file
221
__simulation__/rooms.py
Normal file
@ -0,0 +1,221 @@
|
||||
import config
|
||||
from __simulation__.devices import shelly, silvercrest_powerplug, tradfri_light, tradfri_button, silvercrest_motion_sensor, my_powerplug, remote, brennenstuhl_radiator_valve
|
||||
from __simulation__.devices import gui_light, gui_led_array, gui_radiator_valve
|
||||
import inspect
|
||||
|
||||
|
||||
class base(object):
|
||||
def getmembers(self, prefix=''):
|
||||
rv = []
|
||||
for name, obj in inspect.getmembers(self):
|
||||
if prefix:
|
||||
full_name = prefix + '.' + name
|
||||
else:
|
||||
full_name = name
|
||||
if not name.startswith('_'):
|
||||
try:
|
||||
if obj.__module__.endswith('devices'):
|
||||
rv.append(full_name)
|
||||
else:
|
||||
rv.extend(obj.getmembers(full_name))
|
||||
except AttributeError:
|
||||
pass
|
||||
return rv
|
||||
|
||||
def getobjbyname(self, name):
|
||||
obj = self
|
||||
for subname in name.split('.'):
|
||||
obj = getattr(obj, subname)
|
||||
return obj
|
||||
|
||||
def command(self, full_command):
|
||||
try:
|
||||
parameter = " " + full_command.split(' ')[1]
|
||||
except IndexError:
|
||||
parameter = ""
|
||||
command = full_command.split(' ')[0].split('.')[-1] + parameter
|
||||
device_name = '.'.join(full_command.split(' ')[0].split('.')[:-1])
|
||||
self.getobjbyname(device_name).command(command)
|
||||
|
||||
|
||||
class gfw_floor(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_GUI, True, True, True)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.main_light_zigbee_1 = tradfri_light(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_1_ZIGBEE, True, True, True, False)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee_1.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee_1.power_off, "off")
|
||||
self.main_light_zigbee_2 = tradfri_light(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_2_ZIGBEE, True, True, True, False)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee_2.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee_1.power_off, "off")
|
||||
|
||||
|
||||
class gfw_marion(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_GFW_MARION_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_GFW_MARION_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
|
||||
|
||||
class gfw_dirk(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_GFW_DIRK_MAIN_LIGHT_GUI, True, True, True)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_GFW_DIRK_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.main_light_zigbee = tradfri_light(mqtt_client, config.TOPIC_GFW_DIRK_MAIN_LIGHT_ZIGBEE, True, True, True)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_off, "off")
|
||||
#
|
||||
self.powerplug = my_powerplug(mqtt_client, config.TOPIC_GFW_DIRK_POWERPLUG)
|
||||
self.powerplug.add_channel_name(my_powerplug.KEY_OUTPUT_0, "Amplifier")
|
||||
self.powerplug.add_channel_name(my_powerplug.KEY_OUTPUT_1, "Desk_Light")
|
||||
self.powerplug.add_channel_name(my_powerplug.KEY_OUTPUT_2, "CD_Player")
|
||||
self.powerplug.add_channel_name(my_powerplug.KEY_OUTPUT_3, "PC_Dock")
|
||||
self.gui_amplifier = gui_light(mqtt_client, config.TOPIC_GFW_DIRK_AMPLIFIER_GUI, True, False, False)
|
||||
self.gui_desk_light = gui_light(mqtt_client, config.TOPIC_GFW_DIRK_DESK_LIGHT_GUI, True, True, True)
|
||||
self.desk_light_zigbee = tradfri_light(mqtt_client, config.TOPIC_GFW_DIRK_DESK_LIGHT_ZIGBEE, True, True, True)
|
||||
self.powerplug.add_callback(my_powerplug.KEY_OUTPUT_1, self.desk_light_zigbee.power_on, True)
|
||||
self.powerplug.add_callback(my_powerplug.KEY_OUTPUT_1, self.desk_light_zigbee.power_off, False)
|
||||
self.gui_cd_player = gui_light(mqtt_client, config.TOPIC_GFW_DIRK_CD_PLAYER_GUI, True, False, False)
|
||||
self.gui_pc_dock = gui_light(mqtt_client, config.TOPIC_GFW_DIRK_PC_DOCK_GUI, True, False, False)
|
||||
#
|
||||
self.remote = remote(mqtt_client, config.TOPIC_GFW_DIRK_AMPLIFIER_REMOTE)
|
||||
#
|
||||
self.input_device = tradfri_button(mqtt_client, config.TOPIC_GFW_DIRK_INPUT_DEVICE)
|
||||
self.led_array = gui_led_array(mqtt_client, config.TOPIC_GFW_DIRK_DEVICE_CHOOSER_LED)
|
||||
self.led_array.add_channel_name(gui_led_array.KEY_LED_0, "Main Light")
|
||||
self.led_array.add_channel_name(gui_led_array.KEY_LED_1, "Desk Light")
|
||||
self.led_array.add_channel_name(gui_led_array.KEY_LED_2, "Amplifier")
|
||||
|
||||
|
||||
class gfw(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.floor = gfw_floor(mqtt_client)
|
||||
self.marion = gfw_marion(mqtt_client)
|
||||
self.dirk = gfw_dirk(mqtt_client)
|
||||
|
||||
|
||||
class ffw_julian(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_GUI, True, True, True)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.main_light_zigbee = tradfri_light(mqtt_client, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_ZIGBEE, True, True, True)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_off, "off")
|
||||
|
||||
|
||||
class ffw_livingroom(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFW_LIVINGROOM_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFW_LIVINGROOM_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
|
||||
|
||||
class ffw(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.julian = ffw_julian(mqtt_client)
|
||||
self.livingroom = ffw_livingroom(mqtt_client)
|
||||
|
||||
|
||||
class ffe_floor(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFE_FLOOR_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFE_FLOOR_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
|
||||
|
||||
class ffe_kitchen(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFE_KITCHEN_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFE_KITCHEN_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
#
|
||||
self.gui_circulation_pump = gui_light(mqtt_client, config.TOPIC_FFE_KITCHEN_CIRCULATION_PUMP_GUI, True, False, False)
|
||||
self.circulation_pump = shelly(mqtt_client, config.TOPIC_FFE_KITCHEN_CIRCULATION_PUMP_SHELLY,
|
||||
input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER, output_0_auto_off=10*60)
|
||||
self.circulation_pump.add_channel_name(shelly.KEY_OUTPUT_0, "Circulation Pump")
|
||||
|
||||
|
||||
class ffe_diningroom(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFE_DININGROOM_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFE_DININGROOM_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.gui_floor_lamp = gui_light(mqtt_client, config.TOPIC_FFE_DININGROOM_FLOOR_LAMP_GUI, True, False, False)
|
||||
self.floor_lamp = silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_DININGROOM_FLOOR_LAMP_POWERPLUG)
|
||||
self.floor_lamp.add_channel_name(silvercrest_powerplug.KEY_OUTPUT_0, "Floor Lamp")
|
||||
if config.CHRISTMAS:
|
||||
self.garland = silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_DININGROOM_GARLAND_POWERPLUG)
|
||||
self.garland.add_channel_name(silvercrest_powerplug, "Garland")
|
||||
|
||||
|
||||
class ffe_sleep(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_GUI, True, True, True)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.main_light_zigbee = tradfri_light(mqtt_client, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_ZIGBEE, True, True, True)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_off, "off")
|
||||
#
|
||||
self.gui_bed_light_di = gui_light(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_DI_GUI, True, True, False)
|
||||
self.bed_light_di_zigbee = tradfri_light(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_DI_ZIGBEE, True, True, False)
|
||||
self.gui_bed_light_ma = gui_light(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_MA_GUI, True, False, False)
|
||||
self.bed_light_ma_powerplug = silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_MA_POWERPLUG)
|
||||
#
|
||||
self.input_device = tradfri_button(mqtt_client, config.TOPIC_FFE_SLEEP_INPUT_DEVICE)
|
||||
self.led_array = gui_led_array(mqtt_client, config.TOPIC_FFE_SLEEP_DEVICE_CHOOSER_LED)
|
||||
self.led_array.add_channel_name(gui_led_array.KEY_LED_0, "Main Light")
|
||||
self.led_array.add_channel_name(gui_led_array.KEY_LED_1, "Bed Light Dirk")
|
||||
#
|
||||
self.radiator_valve = brennenstuhl_radiator_valve(mqtt_client, config.TOPIC_FFE_SLEEP_RADIATOR_VALVE_ZIGBEE)
|
||||
self.gui_radiator_valve = gui_radiator_valve(mqtt_client, config.TOPIC_FFE_SLEEP_RADIATOR_VALVE_GUI)
|
||||
|
||||
|
||||
class ffe_livingroom(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_GUI, True, True, True)
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.main_light_zigbee = tradfri_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_ZIGBEE, True, True, True)
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_on, "on")
|
||||
self.main_light.add_callback(shelly.KEY_OUTPUT_0, self.main_light_zigbee.power_off, "off")
|
||||
for i in range(1, 7):
|
||||
setattr(self, "floor_lamp_zigbee_%d" % i, tradfri_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_FLOOR_LAMP_ZIGBEE % i, True, True, True))
|
||||
self.gui_floor_lamp = gui_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_FLOOR_LAMP_GUI, True, True, True)
|
||||
if config.CHRISTMAS:
|
||||
self.xmas_tree = silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_TREE_POWERPLUG)
|
||||
self.xmas_tree.add_channel_name(silvercrest_powerplug, "Xmas-Tree")
|
||||
self.gui_xmas_tree = gui_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_TREE_GUI)
|
||||
self.xmas_star = silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_STAR_POWERPLUG)
|
||||
self.xmas_star.add_channel_name(silvercrest_powerplug, "Xmas-Star")
|
||||
|
||||
|
||||
class ffe(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.floor = ffe_floor(mqtt_client)
|
||||
self.kitchen = ffe_kitchen(mqtt_client)
|
||||
self.diningroom = ffe_diningroom(mqtt_client)
|
||||
self.sleep = ffe_sleep(mqtt_client)
|
||||
self.livingroom = ffe_livingroom(mqtt_client)
|
||||
|
||||
|
||||
class stairway(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gui_main_light = gui_light(mqtt_client, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_GUI, True, False, False)
|
||||
self.gui_main_light.add_led_name(self.gui_main_light.KEY_LED_X % 0, "Motion Ground Floor")
|
||||
self.gui_main_light.add_led_name(self.gui_main_light.KEY_LED_X % 1, "Motion First Floor")
|
||||
self.main_light = shelly(mqtt_client, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_SHELLY, input_0_func=shelly.INPUT_FUNC_OUT1_TRIGGER)
|
||||
self.main_light.add_channel_name(shelly.KEY_OUTPUT_0, "Main Light")
|
||||
self.motion_sensor_gf = silvercrest_motion_sensor(mqtt_client, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_MOTION_SENSOR_GF)
|
||||
self.motion_sensor_ff = silvercrest_motion_sensor(mqtt_client, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_MOTION_SENSOR_FF)
|
||||
|
||||
|
||||
class house(base):
|
||||
def __init__(self, mqtt_client):
|
||||
self.gfw = gfw(mqtt_client)
|
||||
self.ffw = ffw(mqtt_client)
|
||||
self.ffe = ffe(mqtt_client)
|
||||
self.stairway = stairway(mqtt_client)
|
||||
232
__simulation__/test.py
Normal file
232
__simulation__/test.py
Normal file
@ -0,0 +1,232 @@
|
||||
import colored
|
||||
import time
|
||||
|
||||
|
||||
DT_TOGGLE = 0.1
|
||||
|
||||
|
||||
class test_smarthome(object):
|
||||
def __init__(self, house):
|
||||
self.house = house
|
||||
|
||||
def __smoke__(self):
|
||||
result = ""
|
||||
result += "Smoke-Test\n"
|
||||
result += " GUI Element exists for every shelly instance\n"
|
||||
result += self.__gui_element_exists__("shelly")
|
||||
result += " On-Off test for every shelly instance\n"
|
||||
result += self.__on_off_test__("shelly")
|
||||
result += " GUI Element exists for every silvercrest_powerplug instance\n"
|
||||
result += self.__gui_element_exists__("silvercrest_powerplug")
|
||||
result += " On-Off test for every silvercrest_powerplug instance\n"
|
||||
result += self.__on_off_test__("silvercrest_powerplug")
|
||||
result += " GUI Element exists for every my_powerplug instance and port\n"
|
||||
result += self.__gui_element_exists_my_powerplug__()
|
||||
result += " On-Off test for every my_powerplug instance\n"
|
||||
result += self.__on_off_test_my_powerplug__()
|
||||
result += " GUI Element exists for every tradfri_light instance\n"
|
||||
result += self.__gui_element_exists__("tradfri_light")
|
||||
result += " Enable and disable test for gui elements corresponding with tradfri_light\n"
|
||||
result += self.__br_ct_enable_test__()
|
||||
result += " Chnage brightness and color_temp by gui test\n"
|
||||
result += self.__br_ct_change_test__()
|
||||
return result
|
||||
|
||||
def __full__(self):
|
||||
result = "Full-Test"
|
||||
return result
|
||||
|
||||
def smoke(self):
|
||||
print(self.__smoke__())
|
||||
|
||||
def full(self):
|
||||
out = self.__smoke__()
|
||||
out += self.__full__()
|
||||
print(out)
|
||||
|
||||
def print_error(self, text, lvl=2):
|
||||
return lvl*" " + colored.fg("light_red") + '* ' + text + "\n" + colored.attr("reset")
|
||||
|
||||
def print_success(self, text, lvl=2):
|
||||
return lvl*" " + colored.fg("light_green") + '* ' + text + "\n" + colored.attr("reset")
|
||||
|
||||
def __gui_element_exists__(self, obj_name):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == obj_name:
|
||||
if obj_name == "tradfri_light":
|
||||
basename = member[:member.index('_zigbee')]
|
||||
else:
|
||||
basename = member
|
||||
try:
|
||||
gui = self.house.getobjbyname('.'.join(basename.split('.')[:-1]) + '.gui_' + basename.split('.')[-1])
|
||||
except AttributeError:
|
||||
result += self.print_error("No GUI element available, while testing %s (%s)." % (member, obj_name))
|
||||
else:
|
||||
result += self.print_success("GUI element available, while testing %s (%s)." % (member, obj_name))
|
||||
return result
|
||||
|
||||
def __gui_element_exists_my_powerplug__(self):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == "my_powerplug":
|
||||
for channel in [obj.KEY_OUTPUT_0, obj.KEY_OUTPUT_1, obj.KEY_OUTPUT_2, obj.KEY_OUTPUT_3]:
|
||||
try:
|
||||
gui = self.house.getobjbyname('.'.join(member.split(
|
||||
'.')[:-1]) + '.gui_' + obj.names.get(channel.lower(), "__dummy__").lower())
|
||||
except AttributeError:
|
||||
result += self.print_error("No GUI element available, while testing %s (%s)." % (member, obj.names.get(channel)))
|
||||
else:
|
||||
result += self.print_success("GUI element available, while testing %s (%s)." % (member, obj.names.get(channel)))
|
||||
return result
|
||||
|
||||
def __on_off_test_my_powerplug__(self):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == "my_powerplug":
|
||||
for channel in [obj.KEY_OUTPUT_0, obj.KEY_OUTPUT_1, obj.KEY_OUTPUT_2, obj.KEY_OUTPUT_3]:
|
||||
try:
|
||||
gui = self.house.getobjbyname('.'.join(member.split(
|
||||
'.')[:-1]) + '.gui_' + obj.names.get(channel.lower(), "__dummy__").lower())
|
||||
except AttributeError:
|
||||
raise AttributeError
|
||||
pass # exists test already covers non existing gui-elements
|
||||
else:
|
||||
success = True
|
||||
# Initial state equal between obj and gui
|
||||
obj_state = obj.data.get(channel)
|
||||
gui_state = gui.data.get(gui.KEY_STATE)
|
||||
if obj_state != gui_state:
|
||||
result += self.print_error("Initial state of %s (%s) is not equal to GUI state (%s), while testing %s (%s)" %
|
||||
("my_powerplug", obj_state, gui_state, member, obj.names.get(channel)))
|
||||
success = False
|
||||
# state obj change results in state change of obj and gui
|
||||
for i in range(1, 3):
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
last_obj_state = obj_state
|
||||
obj_state = obj.data.get(channel)
|
||||
gui_state = gui.data.get(gui.KEY_STATE)
|
||||
if last_obj_state == obj_state:
|
||||
result += self.print_error("State after %d. toggle of gui state: State unchanged (%s), while testing %s (%s)" %
|
||||
(i, obj_state, member, obj.names.get(channel)))
|
||||
success = False
|
||||
if obj_state != gui_state:
|
||||
result += self.print_error("State after %d. toggle of gui state:: State of device (%s) is not equal to GUI state (%s), while testing %s (%s)" %
|
||||
(i, obj_state, gui_state, member, obj.names.get(channel)))
|
||||
success = False
|
||||
#
|
||||
if success:
|
||||
result += self.print_success("On-Off test successfull, while testing %s (%s)." % (member, obj.names.get(channel)))
|
||||
return result
|
||||
|
||||
def __on_off_test__(self, obj_name):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == obj_name:
|
||||
try:
|
||||
gui = self.house.getobjbyname('.'.join(member.split('.')[:-1]) + '.gui_' + member.split('.')[-1])
|
||||
except AttributeError:
|
||||
pass # exists test already covers non existing gui-elements
|
||||
else:
|
||||
success = True
|
||||
# Initial state equal between obj and gui
|
||||
obj_state = obj.data.get(obj.KEY_OUTPUT_0).lower() == "on"
|
||||
gui_state = gui.data.get(gui.KEY_STATE)
|
||||
if obj_state != gui_state:
|
||||
result += self.print_error("Initial state of %s (%s) is not equal to GUI state (%s), while testing %s (%s)" %
|
||||
(obj_name, obj_state, gui_state, member, obj_name))
|
||||
success = False
|
||||
# state obj change results in state change of obj and gui
|
||||
for i in range(1, 3):
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
last_obj_state = obj_state
|
||||
obj_state = obj.data.get(obj.KEY_OUTPUT_0).lower() == "on"
|
||||
gui_state = gui.data.get(gui.KEY_STATE)
|
||||
if last_obj_state == obj_state:
|
||||
result += self.print_error("State after %d. toggle of gui state: State unchanged (%s), while testing %s (%s)" %
|
||||
(i, obj_state, member, obj_name))
|
||||
success = False
|
||||
if obj_state != gui_state:
|
||||
result += self.print_error("State after %d. toggle of gui state:: State of device (%s) is not equal to GUI state (%s), while testing %s (%s)" %
|
||||
(i, obj_state, gui_state, member, obj_name))
|
||||
success = False
|
||||
#
|
||||
if success:
|
||||
result += self.print_success("On-Off test successfull, while testing %s." % (member))
|
||||
return result
|
||||
|
||||
def __br_ct_enable_test__(self):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == "tradfri_light":
|
||||
basename = member[:member.index('_zigbee')]
|
||||
gui = self.house.getobjbyname('.'.join(basename.split('.')[:-1]) + '.gui_' + basename.split('.')[-1])
|
||||
success = True
|
||||
#
|
||||
if gui.data.get(gui.KEY_ENABLE) != False:
|
||||
result += self.print_error("Inital enable state is not False, while testing %s." % (member))
|
||||
success = False
|
||||
#
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
if gui.data.get(gui.KEY_ENABLE) != True:
|
||||
result += self.print_error("Enable state is not True after switching on, while testing %s." % (member))
|
||||
success = False
|
||||
#
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
if gui.data.get(gui.KEY_ENABLE) != False:
|
||||
result += self.print_error("Enable state is not False after switching off, while testing %s." % (member))
|
||||
success = False
|
||||
#
|
||||
if success:
|
||||
result += self.print_success("Enable-Disable test successfull, while testing %s." % (member))
|
||||
return result
|
||||
|
||||
def __br_ct_change_test__(self):
|
||||
result = ""
|
||||
for member in self.house.getmembers():
|
||||
obj = self.house.getobjbyname(member)
|
||||
if obj.__class__.__name__ == "tradfri_light":
|
||||
basename = member[:member.index('_zigbee')]
|
||||
gui = self.house.getobjbyname('.'.join(basename.split('.')[:-1]) + '.gui_' + basename.split('.')[-1])
|
||||
success = True
|
||||
#
|
||||
if gui.data.get(gui.KEY_STATE) != True:
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
if gui.data.get(gui.KEY_STATE) != True:
|
||||
result += self.print_error("Unable to switch on light, while testing %s." % (member))
|
||||
success = False
|
||||
continue
|
||||
#
|
||||
if "set_brightness" in obj.capabilities():
|
||||
brightness = gui.data.get(obj.KEY_BRIGHTNESS)
|
||||
targetvalue = brightness + (25 if brightness <= 50 else -25)
|
||||
gui.command("set_brightness %d" % targetvalue)
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
if gui.data.get(obj.KEY_BRIGHTNESS) != targetvalue:
|
||||
result += self.print_error("Brightness change by gui was not successfull, while testing %s." % (member))
|
||||
success = False
|
||||
if "set_color_temp" in obj.capabilities():
|
||||
color_temp = gui.data.get(obj.KEY_COLOR_TEMP)
|
||||
targetvalue = color_temp + (3 if color_temp <= 5 else -3)
|
||||
gui.command("set_color_temp %d" % targetvalue)
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
if gui.data.get(obj.KEY_COLOR_TEMP) != targetvalue:
|
||||
result += self.print_error("Color temperature change by gui was not successfull, while testing %s." % (member))
|
||||
success = False
|
||||
#
|
||||
gui.command("toggle_state")
|
||||
time.sleep(2 * DT_TOGGLE)
|
||||
#
|
||||
if success:
|
||||
result += self.print_success("Brightness-ColorTemp test successfull, while testing %s." % (member))
|
||||
return result
|
||||
File diff soppresso perché troppo grande
Carica Diff
199977
_testresults_/testrun.json
199977
_testresults_/testrun.json
File diff soppresso perché troppo grande
Carica Diff
File binario non mostrato.
@ -1,32 +0,0 @@
|
||||
import geo
|
||||
import logging
|
||||
|
||||
DEBUG = False
|
||||
#
|
||||
# Logging
|
||||
#
|
||||
APP_NAME = "smart_brain"
|
||||
LOG_HOSTNAME = "loggy" # When DEBUG is True
|
||||
LOG_LEVEL = logging.INFO # STDOUT logging
|
||||
|
||||
|
||||
#
|
||||
# Application
|
||||
#
|
||||
GEO_POSITION = geo.gps.coordinate(lat=49.519167, lon=9.3672222)
|
||||
|
||||
|
||||
MQTT_SERVER = "{{ smart_srv_brain_hostname }}"
|
||||
MQTT_PORT = 1883
|
||||
MQTT_USER = "{{ smart_srv_brain_username }}"
|
||||
MQTT_PASSWORD = "{{ smart_srv_brain_password }}"
|
||||
|
||||
|
||||
CHRISTMAS = True
|
||||
|
||||
#
|
||||
# PARAMETERS
|
||||
#
|
||||
USER_ON_TIME_STAIRWAYS = 100
|
||||
|
||||
DEFAULT_TEMPERATURE = 21.5
|
||||
1
devdi
1
devdi
@ -1 +0,0 @@
|
||||
Subproject commit 0e45aed92670510d7125b529a26d72f556a40924
|
||||
@ -1,98 +1,912 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
"""
|
||||
devices (DEVICES)
|
||||
=================
|
||||
|
||||
**Author:**
|
||||
|
||||
* Dirk Alders <sudo-dirk@mount-mockery.de>
|
||||
|
||||
**Description:**
|
||||
|
||||
This Module supports smarthome devices
|
||||
|
||||
**Submodules:**
|
||||
|
||||
* :mod:`shelly`
|
||||
* :mod:`silvercrest_powerplug`
|
||||
|
||||
**Unittest:**
|
||||
|
||||
See also the :download:`unittest <devices/_testresults_/unittest.pdf>` documentation.
|
||||
|
||||
**Module Documentation:**
|
||||
|
||||
"""
|
||||
|
||||
__DEPENDENCIES__ = []
|
||||
|
||||
import json
|
||||
import logging
|
||||
|
||||
from smart_devices.shelly import shelly as shelly_sw1
|
||||
from smart_devices.shelly import shelly_rpc as shelly_pro3
|
||||
from smart_devices.hue import hue_light as hue_sw_br_ct
|
||||
from smart_devices.tradfri import tradfri_light as tradfri_sw
|
||||
from smart_devices.tradfri import tradfri_light as tradfri_sw_br
|
||||
from smart_devices.tradfri import tradfri_light as tradfri_sw_br_ct
|
||||
from smart_devices.tradfri import tradfri_button as tradfri_button
|
||||
from smart_devices.tradfri import tradfri_light as livarno_sw_br_ct
|
||||
from smart_devices.brennenstuhl import brennenstuhl_heatingvalve
|
||||
from smart_devices.silvercrest import silvercrest_button
|
||||
from smart_devices.silvercrest import silvercrest_powerplug
|
||||
from smart_devices.silvercrest import silvercrest_motion_sensor
|
||||
from smart_devices.mydevices import powerplug as my_powerplug
|
||||
from smart_devices.mydevices import audio_status
|
||||
from smart_devices.mydevices import remote
|
||||
|
||||
from smart_devices.videv import videv_switching as videv_sw
|
||||
from smart_devices.videv import videv_switch_brightness as videv_sw_br
|
||||
from smart_devices.videv import videv_switch_brightness_color_temp as videv_sw_br_ct
|
||||
from smart_devices.videv import videv_switching_timer as videv_sw_tm
|
||||
from smart_devices.videv import videv_switching_motion as videv_sw_mo
|
||||
from smart_devices.videv import videv_heating as videv_hea
|
||||
from smart_devices.videv import videv_pure_switch
|
||||
from smart_devices.videv import videv_multistate
|
||||
from smart_devices.videv import videv_audio_player
|
||||
from smart_devices.videv import videv_all_off
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
except ImportError:
|
||||
ROOT_LOGGER_NAME = 'root'
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
BATTERY_WARN_LEVEL = 5
|
||||
|
||||
|
||||
def my_ambient(mqtt_client, topic):
|
||||
logger.warning("Device type my_ambient is not yet implemented. Topic %s will not be supported", topic)
|
||||
return None
|
||||
def is_json(data):
|
||||
try:
|
||||
json.loads(data)
|
||||
except json.decoder.JSONDecodeError:
|
||||
return False
|
||||
else:
|
||||
return True
|
||||
|
||||
|
||||
class group(object):
|
||||
def __init__(self, *args):
|
||||
super().__init__()
|
||||
self._members = args
|
||||
self._iter_counter = 0
|
||||
class base(dict):
|
||||
TX_TOPIC = "set"
|
||||
TX_VALUE = 0
|
||||
TX_DICT = 1
|
||||
TX_TYPE = -1
|
||||
TX_FILTER_DATA_KEYS = []
|
||||
#
|
||||
RX_KEYS = []
|
||||
RX_IGNORE_TOPICS = []
|
||||
RX_IGNORE_KEYS = []
|
||||
RX_FILTER_DATA_KEYS = []
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
# data storage
|
||||
self.mqtt_client = mqtt_client
|
||||
self.topic = topic
|
||||
self.logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
for entry in self.topic.split('/'):
|
||||
self.logger = self.logger.getChild(entry)
|
||||
# initialisations
|
||||
dict.__init__(self)
|
||||
mqtt_client.add_callback(
|
||||
topic=self.topic, callback=self.receive_callback)
|
||||
mqtt_client.add_callback(
|
||||
topic=self.topic+"/#", callback=self.receive_callback)
|
||||
#
|
||||
self.methods = []
|
||||
self.variables = []
|
||||
for name in [m for m in args[0].__class__.__dict__.keys()]:
|
||||
if not name.startswith('_') and callable(getattr(args[0], name)): # add all public callable attributes to the list
|
||||
self.methods.append(name)
|
||||
if not name.startswith('_') and not callable(getattr(args[0], name)): # add all public callable attributes to the list
|
||||
self.variables.append(name)
|
||||
self.callback_list = []
|
||||
self.warning_callback = None
|
||||
#
|
||||
for member in self:
|
||||
methods = [m for m in member.__class__.__dict__.keys() if not m.startswith(
|
||||
'_') if not m.startswith('_') and callable(getattr(args[0], m))]
|
||||
if self.methods != methods:
|
||||
raise ValueError("All given instances needs to have same methods:", self.methods, methods)
|
||||
#
|
||||
variables = [v for v in member.__class__.__dict__.keys() if not v.startswith(
|
||||
'_') if not v.startswith('_') and not callable(getattr(args[0], v))]
|
||||
if self.variables != variables:
|
||||
raise ValueError("All given instances needs to have same variables:", self.variables, variables)
|
||||
self.__previous__ = {}
|
||||
|
||||
def __iter__(self):
|
||||
return self
|
||||
def receive_callback(self, client, userdata, message):
|
||||
self.unpack(message)
|
||||
|
||||
def __next__(self):
|
||||
if self._iter_counter < len(self):
|
||||
self._iter_counter += 1
|
||||
return self._members[self._iter_counter - 1]
|
||||
self._iter_counter = 0
|
||||
raise StopIteration
|
||||
def unpack_filter(self, key):
|
||||
if key in self.RX_FILTER_DATA_KEYS:
|
||||
if self.get(key) == 1 or self.get(key) == 'on' or self.get(key) == 'ON':
|
||||
self[key] = True
|
||||
elif self.get(key) == 0 or self.get(key) == 'off' or self.get(key) == 'OFF':
|
||||
self[key] = False
|
||||
|
||||
def __getitem__(self, i):
|
||||
return self._members[i]
|
||||
|
||||
def __len__(self):
|
||||
return len(self._members)
|
||||
|
||||
def __getattribute__(self, name):
|
||||
def group_execution(*args, **kwargs):
|
||||
for member in self[:]:
|
||||
m = getattr(member, name)
|
||||
m(*args, **kwargs)
|
||||
try:
|
||||
rv = super().__getattribute__(name)
|
||||
except AttributeError:
|
||||
if callable(getattr(self[0], name)):
|
||||
return group_execution
|
||||
else:
|
||||
return getattr(self[0], name)
|
||||
def unpack_single_value(self, key, data):
|
||||
prev_value = self.get(key)
|
||||
if key in self.RX_KEYS:
|
||||
self[key] = data
|
||||
self.__previous__[key] = prev_value
|
||||
# Filter, if needed
|
||||
self.unpack_filter(key)
|
||||
self.logger.debug("Received data %s - %s", key, str(self.get(key)))
|
||||
self.callback_caller(key, self[key], self.get(key) != self.__previous__.get(key))
|
||||
elif key not in self.RX_IGNORE_KEYS:
|
||||
self.logger.warning('Got a message with unparsed content: "%s - %s"', key, str(data))
|
||||
else:
|
||||
return rv
|
||||
self.logger.debug("Ignoring key %s", key)
|
||||
|
||||
def unpack(self, message):
|
||||
content_key = message.topic[len(self.topic) + 1:]
|
||||
if content_key not in self.RX_IGNORE_TOPICS and (not message.topic.endswith(self.TX_TOPIC) or len(self.TX_TOPIC) == 0):
|
||||
self.logger.debug("Unpacking content_key \"%s\" from message.", content_key)
|
||||
if is_json(message.payload):
|
||||
data = json.loads(message.payload)
|
||||
if type(data) is dict:
|
||||
for key in data:
|
||||
self.unpack_single_value(key, data[key])
|
||||
else:
|
||||
self.unpack_single_value(content_key, data)
|
||||
# String
|
||||
else:
|
||||
self.unpack_single_value(
|
||||
content_key, message.payload.decode('utf-8'))
|
||||
self.warning_caller()
|
||||
else:
|
||||
self.logger.debug("Ignoring topic %s", content_key)
|
||||
|
||||
def pack_filter(self, key, data):
|
||||
if key in self.TX_FILTER_DATA_KEYS:
|
||||
if data is True:
|
||||
return "on"
|
||||
elif data is False:
|
||||
return "off"
|
||||
else:
|
||||
return data
|
||||
return data
|
||||
|
||||
def set(self, key, data):
|
||||
self.pack(key, data)
|
||||
|
||||
def pack(self, key, data):
|
||||
data = self.pack_filter(key, data)
|
||||
if self.TX_TOPIC is not None:
|
||||
if self.TX_TYPE < 0:
|
||||
self.logger.error("Unknown tx type. Set TX_TYPE of class to a known value")
|
||||
else:
|
||||
self.logger.debug("Sending data for %s - %s", key, str(data))
|
||||
if self.TX_TYPE == self.TX_DICT:
|
||||
self.mqtt_client.send('/'.join([self.topic, self.TX_TOPIC]), json.dumps({key: data}))
|
||||
else:
|
||||
if type(data) not in [str, bytes]:
|
||||
data = json.dumps(data)
|
||||
self.mqtt_client.send('/'.join([self.topic, key, self.TX_TOPIC] if len(self.TX_TOPIC) > 0 else [self.topic, key]), data)
|
||||
else:
|
||||
self.logger.error("Unknown tx toptic. Set TX_TOPIC of class to a known value")
|
||||
|
||||
def add_callback(self, key, data, callback, on_change_only=False):
|
||||
"""
|
||||
key: key or None for all keys
|
||||
data: data or None for all data
|
||||
"""
|
||||
cb_tup = (key, data, callback, on_change_only)
|
||||
if cb_tup not in self.callback_list:
|
||||
self.callback_list.append(cb_tup)
|
||||
|
||||
def add_warning_callback(self, callback):
|
||||
self.warning_callback = callback
|
||||
|
||||
def warning_call_condition(self):
|
||||
return False
|
||||
|
||||
def callback_caller(self, key, data, value_changed):
|
||||
for cb_key, cb_data, callback, on_change_only in self.callback_list:
|
||||
if (cb_key == key or cb_key is None) and (cb_data == data or cb_data is None) and callback is not None:
|
||||
if not on_change_only or value_changed:
|
||||
callback(self, key, data)
|
||||
|
||||
def warning_caller(self):
|
||||
if self.warning_call_condition():
|
||||
warn_txt = self.warning_text()
|
||||
self.logger.warning(warn_txt)
|
||||
if self.warning_callback is not None:
|
||||
self.warning_callback(self, warn_txt)
|
||||
|
||||
def warning_text(self):
|
||||
return "default warning text - replace parent warning_text function"
|
||||
|
||||
def previous_value(self, key):
|
||||
return self.__previous__.get(key)
|
||||
|
||||
|
||||
class shelly(base):
|
||||
KEY_OUTPUT_0 = "relay/0"
|
||||
KEY_OUTPUT_1 = "relay/1"
|
||||
KEY_INPUT_0 = "input/0"
|
||||
KEY_INPUT_1 = "input/1"
|
||||
KEY_LONGPUSH_0 = "longpush/0"
|
||||
KEY_LONGPUSH_1 = "longpush/1"
|
||||
KEY_TEMPERATURE = "temperature"
|
||||
KEY_OVERTEMPERATURE = "overtemperature"
|
||||
KEY_ID = "id"
|
||||
KEY_MODEL = "model"
|
||||
KEY_MAC = "mac"
|
||||
KEY_IP = "ip"
|
||||
KEY_NEW_FIRMWARE = "new_fw"
|
||||
KEY_FIRMWARE_VERSION = "fw_ver"
|
||||
#
|
||||
TX_TOPIC = "command"
|
||||
TX_TYPE = base.TX_VALUE
|
||||
TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1]
|
||||
#
|
||||
RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OVERTEMPERATURE, KEY_TEMPERATURE,
|
||||
KEY_ID, KEY_MODEL, KEY_MAC, KEY_IP, KEY_NEW_FIRMWARE, KEY_FIRMWARE_VERSION]
|
||||
RX_IGNORE_TOPICS = [KEY_OUTPUT_0 + '/' + "energy", KEY_OUTPUT_1 + '/' + "energy", 'input_event/0', 'input_event/1']
|
||||
RX_IGNORE_KEYS = ['temperature_f']
|
||||
RX_FILTER_DATA_KEYS = [KEY_INPUT_0, KEY_INPUT_1, KEY_LONGPUSH_0, KEY_LONGPUSH_1, KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OVERTEMPERATURE]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
#
|
||||
# WARNING CALL
|
||||
#
|
||||
def warning_call_condition(self):
|
||||
return self.get(self.KEY_OVERTEMPERATURE)
|
||||
|
||||
def warning_text(self):
|
||||
if self.overtemperature:
|
||||
if self.temperature is not None:
|
||||
return "Overtemperature detected for %s. Temperature was %.1f°C." % (self.topic, self.temperature)
|
||||
else:
|
||||
return "Overtemperature detected for %s." % self.topic
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def output_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_0)
|
||||
|
||||
@property
|
||||
def output_1(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_1)
|
||||
|
||||
@property
|
||||
def input_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_INPUT_0)
|
||||
|
||||
@property
|
||||
def input_1(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_INPUT_1)
|
||||
|
||||
@property
|
||||
def longpush_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_LONGPUSH_0)
|
||||
|
||||
@property
|
||||
def longpush_1(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_LONGPUSH_1)
|
||||
|
||||
@property
|
||||
def temperature(self):
|
||||
"""rv: numeric value"""
|
||||
return self.get(self.KEY_TEMPERATURE)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_output_0(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_0, state)
|
||||
|
||||
def set_output_0_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
|
||||
self.set_output_0(data)
|
||||
|
||||
def toggle_output_0_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 0")
|
||||
self.set_output_0('toggle')
|
||||
|
||||
def set_output_1(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_1, state)
|
||||
|
||||
def set_output_1_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_1 else logging.DEBUG, "Changing output 1 to %s", str(data))
|
||||
self.set_output_1(data)
|
||||
|
||||
def toggle_output_1_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 1")
|
||||
self.set_output_1('toggle')
|
||||
|
||||
|
||||
class silvercrest_powerplug(base):
|
||||
KEY_LINKQUALITY = "linkquality"
|
||||
KEY_OUTPUT_0 = "state"
|
||||
#
|
||||
TX_TYPE = base.TX_DICT
|
||||
TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0]
|
||||
#
|
||||
RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0]
|
||||
RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def output_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_0)
|
||||
|
||||
@property
|
||||
def linkquality(self):
|
||||
"""rv: numeric value"""
|
||||
return self.get(self.KEY_LINKQUALITY)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_output_0(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_0, state)
|
||||
|
||||
def set_output_0_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
|
||||
self.set_output_0(data)
|
||||
|
||||
def toggle_output_0_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 0")
|
||||
self.set_output_0('toggle')
|
||||
|
||||
|
||||
class silvercrest_motion_sensor(base):
|
||||
KEY_BATTERY = "battery"
|
||||
KEY_BATTERY_LOW = "battery_low"
|
||||
KEY_LINKQUALITY = "linkquality"
|
||||
KEY_OCCUPANCY = "occupancy"
|
||||
KEY_UNMOUNTED = "tamper"
|
||||
KEY_VOLTAGE = "voltage"
|
||||
#
|
||||
RX_KEYS = [KEY_BATTERY, KEY_BATTERY_LOW, KEY_LINKQUALITY, KEY_OCCUPANCY, KEY_UNMOUNTED, KEY_VOLTAGE]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
def warning_call_condition(self):
|
||||
return self.get(self.KEY_BATTERY_LOW)
|
||||
|
||||
def warning_text(self, data):
|
||||
return "Battery low: level=%d" % self.get(self.KEY_BATTERY)
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
|
||||
@property
|
||||
def linkquality(self):
|
||||
"""rv: numeric value"""
|
||||
return self.get(self.KEY_LINKQUALITY)
|
||||
|
||||
|
||||
class my_powerplug(base):
|
||||
KEY_OUTPUT_0 = "output/1"
|
||||
KEY_OUTPUT_1 = "output/2"
|
||||
KEY_OUTPUT_2 = "output/3"
|
||||
KEY_OUTPUT_3 = "output/4"
|
||||
KEY_OUTPUT_ALL = "output/all"
|
||||
KEY_OUTPUT_LIST = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_OUTPUT_3]
|
||||
#
|
||||
TX_TYPE = base.TX_VALUE
|
||||
#
|
||||
RX_KEYS = [KEY_OUTPUT_0, KEY_OUTPUT_1, KEY_OUTPUT_2, KEY_OUTPUT_3]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def output_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_0)
|
||||
|
||||
@property
|
||||
def output_1(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_1)
|
||||
|
||||
@property
|
||||
def output_2(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_2)
|
||||
|
||||
@property
|
||||
def output_3(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_3)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_output(self, key, state):
|
||||
if key in self.KEY_OUTPUT_LIST:
|
||||
self.pack(key, state)
|
||||
else:
|
||||
logging.error("Unknown key to set the output!")
|
||||
|
||||
def set_output_0(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_0, state)
|
||||
|
||||
def set_output_0_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
|
||||
self.set_output_0(data)
|
||||
|
||||
def toggle_output_0_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 0")
|
||||
self.set_output_0('toggle')
|
||||
|
||||
def set_output_1(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_1, state)
|
||||
|
||||
def set_output_1_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_1 else logging.DEBUG, "Changing output 1 to %s", str(data))
|
||||
self.set_output_1(data)
|
||||
|
||||
def toggle_output_1_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 1")
|
||||
self.set_output_1('toggle')
|
||||
|
||||
def set_output_2(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_2, state)
|
||||
|
||||
def set_output_2_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_2 else logging.DEBUG, "Changing output 2 to %s", str(data))
|
||||
self.set_output_2(data)
|
||||
|
||||
def toggle_output_2_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 2")
|
||||
self.set_output_2('toggle')
|
||||
|
||||
def set_output_3(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_3, state)
|
||||
|
||||
def set_output_3_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_3 else logging.DEBUG, "Changing output 3 to %s", str(data))
|
||||
self.set_output_3(data)
|
||||
|
||||
def toggle_output_3_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 3")
|
||||
self.set_output_3('toggle')
|
||||
|
||||
def set_output_all(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_ALL, state)
|
||||
|
||||
def set_output_all_mcb(self, device, key, data):
|
||||
self.logger.info("Changing all outputs to %s", str(data))
|
||||
self.set_output_all(data)
|
||||
|
||||
def toggle_output_all_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling all outputs")
|
||||
self.set_output_0('toggle')
|
||||
|
||||
|
||||
class tradfri_light(base):
|
||||
KEY_LINKQUALITY = "linkquality"
|
||||
KEY_OUTPUT_0 = "state"
|
||||
KEY_BRIGHTNESS = "brightness"
|
||||
KEY_COLOR_TEMP = "color_temp"
|
||||
KEY_BRIGHTNESS_FADE = "brightness_move"
|
||||
#
|
||||
TX_TYPE = base.TX_DICT
|
||||
TX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP, KEY_BRIGHTNESS_FADE]
|
||||
#
|
||||
RX_KEYS = [KEY_LINKQUALITY, KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
|
||||
RX_IGNORE_KEYS = ['update', 'color_mode']
|
||||
RX_FILTER_DATA_KEYS = [KEY_OUTPUT_0, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
def unpack_filter(self, key):
|
||||
if key == self.KEY_BRIGHTNESS:
|
||||
self[key] = (self[key] - 1) * 100 / 254
|
||||
elif key == self.KEY_COLOR_TEMP:
|
||||
self[key] = (self[key] - 250) * 10 / 204
|
||||
else:
|
||||
super().unpack_filter(key)
|
||||
|
||||
def pack_filter(self, key, data):
|
||||
if key == self.KEY_BRIGHTNESS:
|
||||
return data * 254 / 100 + 1
|
||||
elif key == self.KEY_COLOR_TEMP:
|
||||
return data * 204 / 10 + 250
|
||||
else:
|
||||
return super().pack_filter(key, data)
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def output_0(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_OUTPUT_0, False)
|
||||
|
||||
@property
|
||||
def linkquality(self):
|
||||
"""rv: numeric value"""
|
||||
return self.get(self.KEY_LINKQUALITY, 0)
|
||||
|
||||
@property
|
||||
def brightness(self):
|
||||
"""rv: numeric value [0%, ..., 100%]"""
|
||||
return self.get(self.KEY_BRIGHTNESS, 0)
|
||||
|
||||
@property
|
||||
def color_temp(self):
|
||||
"""rv: numeric value [0, ..., 10]"""
|
||||
return self.get(self.KEY_COLOR_TEMP, 0)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_output_0(self, state):
|
||||
"""state: [True, False, 'toggle']"""
|
||||
self.pack(self.KEY_OUTPUT_0, state)
|
||||
|
||||
def set_output_0_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.output_0 else logging.DEBUG, "Changing output 0 to %s", str(data))
|
||||
self.set_output_0(data)
|
||||
|
||||
def toggle_output_0_mcb(self, device, key, data):
|
||||
self.logger.info("Toggeling output 0")
|
||||
self.set_output_0('toggle')
|
||||
|
||||
def set_brightness(self, brightness):
|
||||
"""brightness: [0, ..., 100]"""
|
||||
self.pack(self.KEY_BRIGHTNESS, brightness)
|
||||
|
||||
def set_brightness_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.brightness else logging.DEBUG, "Changing brightness to %s", str(data))
|
||||
self.set_brightness(data)
|
||||
|
||||
def default_inc(self, speed=40):
|
||||
self.pack(self.KEY_BRIGHTNESS_FADE, speed)
|
||||
|
||||
def default_dec(self, speed=-40):
|
||||
self.default_inc(speed)
|
||||
|
||||
def default_stop(self):
|
||||
self.default_inc(0)
|
||||
|
||||
def set_color_temp(self, color_temp):
|
||||
"""color_temp: [0, ..., 10]"""
|
||||
self.pack(self.KEY_COLOR_TEMP, color_temp)
|
||||
|
||||
def set_color_temp_mcb(self, device, key, data):
|
||||
self.logger.log(logging.INFO if data != self.color_temp else logging.DEBUG, "Changing color temperature to %s", str(data))
|
||||
self.set_color_temp(data)
|
||||
|
||||
|
||||
class tradfri_button(base):
|
||||
ACTION_TOGGLE = "toggle"
|
||||
ACTION_BRIGHTNESS_UP = "brightness_up_click"
|
||||
ACTION_BRIGHTNESS_DOWN = "brightness_down_click"
|
||||
ACTION_RIGHT = "arrow_right_click"
|
||||
ACTION_LEFT = "arrow_left_click"
|
||||
ACTION_BRIGHTNESS_UP_LONG = "brightness_up_hold"
|
||||
ACTION_BRIGHTNESS_UP_RELEASE = "brightness_up_release"
|
||||
ACTION_BRIGHTNESS_DOWN_LONG = "brightness_down_hold"
|
||||
ACTION_BRIGHTNESS_DOWN_RELEASE = "brightness_down_release"
|
||||
ACTION_RIGHT_LONG = "arrow_right_hold"
|
||||
ACTION_RIGHT_RELEASE = "arrow_right_release"
|
||||
ACTION_LEFT_LONG = "arrow_left_hold"
|
||||
ACTION_LEFT_RELEASE = "arrow_left_release"
|
||||
#
|
||||
KEY_LINKQUALITY = "linkquality"
|
||||
KEY_BATTERY = "battery"
|
||||
KEY_ACTION = "action"
|
||||
KEY_ACTION_DURATION = "action_duration"
|
||||
#
|
||||
RX_KEYS = [KEY_LINKQUALITY, KEY_BATTERY, KEY_ACTION]
|
||||
RX_IGNORE_KEYS = ['update', KEY_ACTION_DURATION]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def action(self):
|
||||
"""rv: action_txt"""
|
||||
return self.get(self.KEY_ACTION)
|
||||
|
||||
#
|
||||
# WARNING CALL
|
||||
#
|
||||
def warning_call_condition(self):
|
||||
return self.get(self.KEY_BATTERY) is not None and self.get(self.KEY_BATTERY) <= BATTERY_WARN_LEVEL
|
||||
|
||||
def warning_text(self):
|
||||
return "Low battery level detected for %s. Battery level was %.0f%%." % (self.topic, self.get(self.KEY_BATTERY))
|
||||
|
||||
|
||||
class nodered_gui_leds(base):
|
||||
KEY_LED_0 = "led0"
|
||||
KEY_LED_1 = "led1"
|
||||
KEY_LED_2 = "led2"
|
||||
KEY_LED_3 = "led3"
|
||||
KEY_LED_4 = "led4"
|
||||
KEY_LED_5 = "led5"
|
||||
KEY_LED_6 = "led6"
|
||||
KEY_LED_7 = "led7"
|
||||
KEY_LED_8 = "led8"
|
||||
KEY_LED_9 = "led9"
|
||||
KEY_LED_LIST = [KEY_LED_0, KEY_LED_1, KEY_LED_2, KEY_LED_3, KEY_LED_4, KEY_LED_5, KEY_LED_6, KEY_LED_7, KEY_LED_8, KEY_LED_9]
|
||||
#
|
||||
TX_TYPE = base.TX_VALUE
|
||||
|
||||
def set_led(self, key, data):
|
||||
"""data: [True, False]"""
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.pack(key, data)
|
||||
|
||||
|
||||
class nodered_gui_timer(base):
|
||||
KEY_TIMER = "timer"
|
||||
#
|
||||
TX_TYPE = base.TX_VALUE
|
||||
|
||||
def set_timer(self, data):
|
||||
"""data: numeric"""
|
||||
self.pack(self.KEY_TIMER, data)
|
||||
|
||||
def set_timer_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_timer(data)
|
||||
|
||||
|
||||
class nodered_gui_button(base):
|
||||
KEY_STATE = "state"
|
||||
#
|
||||
RX_KEYS = [KEY_STATE]
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def state(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_STATE)
|
||||
|
||||
|
||||
class nodered_gui_switch(nodered_gui_button):
|
||||
TX_TYPE = base.TX_VALUE
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_state(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_STATE, data)
|
||||
|
||||
def set_state_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_state(data)
|
||||
|
||||
|
||||
class nodered_gui_light(nodered_gui_switch, nodered_gui_leds, nodered_gui_timer):
|
||||
KEY_ENABLE = "enable"
|
||||
KEY_BRIGHTNESS = "brightness"
|
||||
KEY_COLOR_TEMP = "color_temp"
|
||||
#
|
||||
TX_TYPE = base.TX_VALUE
|
||||
#
|
||||
RX_KEYS = nodered_gui_switch.RX_KEYS + [KEY_ENABLE, KEY_BRIGHTNESS, KEY_COLOR_TEMP]
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def enable(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_ENABLE)
|
||||
|
||||
@property
|
||||
def brightness(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_BRIGHTNESS)
|
||||
|
||||
@property
|
||||
def color_temp(self):
|
||||
"""rv: [True, False]"""
|
||||
return self.get(self.KEY_COLOR_TEMP)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_enable(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_ENABLE, data)
|
||||
|
||||
def set_enable_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_enable(data)
|
||||
|
||||
def set_brightness(self, data):
|
||||
"""data: [0%, ..., 100%]"""
|
||||
self.pack(self.KEY_BRIGHTNESS, data)
|
||||
|
||||
def set_brightness_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_brightness(data)
|
||||
|
||||
def set_color_temp(self, data):
|
||||
"""data: [0, ..., 10]"""
|
||||
self.pack(self.KEY_COLOR_TEMP, data)
|
||||
|
||||
def set_color_temp_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_color_temp(data)
|
||||
|
||||
|
||||
class nodered_gui_radiator(nodered_gui_timer):
|
||||
KEY_TEMPERATURE = "temperature"
|
||||
KEY_SETPOINT_TEMP = "setpoint_temp"
|
||||
KEY_SETPOINT_TO_DEFAULT = "setpoint_to_default"
|
||||
KEY_BOOST = 'boost'
|
||||
KEY_AWAY = "away"
|
||||
KEY_SUMMER = "summer"
|
||||
KEY_ENABLE = "enable"
|
||||
#
|
||||
RX_KEYS = [KEY_TEMPERATURE, KEY_SETPOINT_TEMP, KEY_SETPOINT_TO_DEFAULT, KEY_BOOST, KEY_AWAY, KEY_SUMMER]
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_temperature(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_TEMPERATURE, data)
|
||||
|
||||
def set_temperature_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_temperature(data)
|
||||
|
||||
def set_setpoint_temperature(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_SETPOINT_TEMP, data)
|
||||
|
||||
def set_setpoint_temperature_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_setpoint_temperature(data)
|
||||
|
||||
def set_away(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_AWAY, data)
|
||||
|
||||
def set_away_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_away(data)
|
||||
|
||||
def set_summer(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_SUMMER, data)
|
||||
|
||||
def set_summer_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_summer(data)
|
||||
|
||||
def set_enable(self, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_ENABLE, data)
|
||||
|
||||
def set_enable_mcb(self, device, key, data):
|
||||
self.logger.debug("Sending %s with content %s", key, str(data))
|
||||
self.set_enable(data)
|
||||
|
||||
|
||||
class brennenstuhl_heatingvalve(base):
|
||||
KEY_LINKQUALITY = "linkquality"
|
||||
KEY_BATTERY = "battery"
|
||||
KEY_HEATING_SETPOINT = "current_heating_setpoint"
|
||||
KEY_TEMPERATURE = "local_temperature"
|
||||
#
|
||||
KEY_AWAY_MODE = "away_mode"
|
||||
KEY_CHILD_LOCK = "child_lock"
|
||||
KEY_PRESET = "preset"
|
||||
KEY_SYSTEM_MODE = "system_mode"
|
||||
KEY_VALVE_DETECTION = "valve_detection"
|
||||
KEY_WINDOW_DETECTION = "window_detection"
|
||||
#
|
||||
TX_TYPE = base.TX_DICT
|
||||
#
|
||||
RX_KEYS = [KEY_LINKQUALITY, KEY_BATTERY, KEY_HEATING_SETPOINT, KEY_TEMPERATURE]
|
||||
RX_IGNORE_KEYS = [KEY_AWAY_MODE, KEY_CHILD_LOCK, KEY_PRESET, KEY_SYSTEM_MODE, KEY_VALVE_DETECTION, KEY_WINDOW_DETECTION]
|
||||
|
||||
def __init__(self, mqtt_client, topic):
|
||||
super().__init__(mqtt_client, topic)
|
||||
self.mqtt_client.send(self.topic + '/' + self.TX_TOPIC, json.dumps({self.KEY_WINDOW_DETECTION: "ON",
|
||||
self.KEY_CHILD_LOCK: "UNLOCK", self.KEY_VALVE_DETECTION: "ON", self.KEY_SYSTEM_MODE: "heat", self.KEY_PRESET: "manual"}))
|
||||
|
||||
def warning_call_condition(self):
|
||||
return self.get(self.KEY_BATTERY, 100) <= BATTERY_WARN_LEVEL
|
||||
|
||||
def warning_text(self):
|
||||
return "Low battery level detected for %s. Battery level was %.0f%%." % (self.topic, self.get(self.KEY_BATTERY))
|
||||
|
||||
#
|
||||
# RX
|
||||
#
|
||||
@property
|
||||
def linkqulity(self):
|
||||
return self.get(self.KEY_LINKQUALITY)
|
||||
|
||||
@property
|
||||
def heating_setpoint(self):
|
||||
return self.get(self.KEY_HEATING_SETPOINT)
|
||||
|
||||
@property
|
||||
def temperature(self):
|
||||
return self.get(self.KEY_TEMPERATURE)
|
||||
|
||||
#
|
||||
# TX
|
||||
#
|
||||
def set_heating_setpoint(self, setpoint):
|
||||
self.pack(self.KEY_HEATING_SETPOINT, setpoint)
|
||||
|
||||
def set_heating_setpoint_mcb(self, device, key, data):
|
||||
self.logger.info("Changing heating setpoint to %s", str(data))
|
||||
self.set_heating_setpoint(data)
|
||||
|
||||
|
||||
class remote(base):
|
||||
KEY_CD = "CD"
|
||||
KEY_LINE1 = "LINE1"
|
||||
KEY_LINE3 = "LINE3"
|
||||
KEY_MUTE = "MUTE"
|
||||
KEY_POWER = "POWER"
|
||||
KEY_VOLDOWN = "VOLDOWN"
|
||||
KEY_VOLUP = "VOLUP"
|
||||
#
|
||||
TX_TOPIC = ''
|
||||
TX_TYPE = base.TX_VALUE
|
||||
#
|
||||
RX_IGNORE_TOPICS = [KEY_CD, KEY_LINE1, KEY_LINE3, KEY_MUTE, KEY_POWER, KEY_VOLUP, KEY_VOLDOWN]
|
||||
|
||||
def set_cd(self, device=None, key=None, data=None):
|
||||
self.pack(self.KEY_CD, None)
|
||||
|
||||
def set_line1(self, device=None, key=None, data=None):
|
||||
self.pack(self.KEY_LINE1, None)
|
||||
|
||||
def set_line3(self, device=None, key=None, data=None):
|
||||
self.pack(self.KEY_LINE3, None)
|
||||
|
||||
def set_mute(self, device=None, key=None, data=None):
|
||||
self.pack(self.KEY_MUTE, None)
|
||||
|
||||
def set_power(self, device=None, key=None, data=None):
|
||||
self.pack(self.KEY_POWER, None)
|
||||
|
||||
def set_volume_up(self, data=False):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_VOLUP, data)
|
||||
|
||||
def set_volume_down(self, data=False):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_VOLDOWN, data)
|
||||
|
||||
def default_inc(self, device=None, key=None, data=None):
|
||||
self.set_volume_up(True)
|
||||
|
||||
def default_dec(self, device=None, key=None, data=None):
|
||||
self.set_volume_down(True)
|
||||
|
||||
def default_stop(self, device=None, key=None, data=None):
|
||||
self.set_volume_up(False)
|
||||
|
||||
|
||||
class status(base):
|
||||
KEY_STATE = "state"
|
||||
#
|
||||
TX_TYPE = base.TX_VALUE
|
||||
#
|
||||
RX_KEYS = [KEY_STATE]
|
||||
|
||||
def set_state(self, num, data):
|
||||
"""data: [True, False]"""
|
||||
self.pack(self.KEY_STATE + "/" + str(num), data)
|
||||
|
||||
def set_state_mcb(self, device, key, data):
|
||||
self.logger.info("Changing state to %s", str(data))
|
||||
self.set_state(data)
|
||||
|
||||
|
||||
class audio_status(status):
|
||||
KEY_TITLE = "title"
|
||||
#
|
||||
RX_KEYS = [status.KEY_STATE, KEY_TITLE]
|
||||
|
||||
@ -1,18 +1,13 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
import config
|
||||
from devdi import rooms as devdi_rooms
|
||||
from devdi.topic import STOP_EXECUTION_TOPIC
|
||||
from function.garden import garden
|
||||
import devices
|
||||
from function.stairway import stairway
|
||||
from function.ground_floor_west import ground_floor_west
|
||||
from function.first_floor_west import first_floor_west
|
||||
from function.first_floor_east import first_floor_east
|
||||
from function.rooms import room_collection
|
||||
import json
|
||||
from function.ground_floor_west import ground_floor_west_floor, ground_floor_west_marion, ground_floor_west_dirk
|
||||
from function.first_floor_west import first_floor_west_julian, first_floor_west_living, first_floor_west_bath
|
||||
from function.first_floor_east import first_floor_east_floor, first_floor_east_kitchen, first_floor_east_dining, first_floor_east_sleep, first_floor_east_living
|
||||
import inspect
|
||||
import logging
|
||||
import mqtt
|
||||
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
@ -20,28 +15,31 @@ except ImportError:
|
||||
ROOT_LOGGER_NAME = 'root'
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
# TODO: implement garland (incl. day events like sunset, sunrise, ...)
|
||||
# TODO: implement warning message
|
||||
|
||||
class all_functions(room_collection, devdi_rooms.collection):
|
||||
def __init__(self, mqtt_client: mqtt.mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
devdi_rooms.collection.__init__(self, mqtt_client)
|
||||
|
||||
class all_functions(object):
|
||||
def __init__(self, mqtt_client):
|
||||
self.mqtt_client = mqtt_client
|
||||
#
|
||||
self.run = True
|
||||
if config.DEBUG:
|
||||
mqtt_client.add_callback(STOP_EXECUTION_TOPIC, self.__stop_execution__)
|
||||
#
|
||||
# Rooms
|
||||
#
|
||||
# garden
|
||||
self.gar = garden(self.mqtt_client)
|
||||
self.__devices__ = None
|
||||
# stairway
|
||||
self.stw = stairway(self.mqtt_client)
|
||||
self.stw_stairway = stairway(self.mqtt_client)
|
||||
# ground floor west
|
||||
self.gfw = ground_floor_west(self.mqtt_client)
|
||||
self.gfw_floor = ground_floor_west_floor(self.mqtt_client)
|
||||
self.gfw_marion = ground_floor_west_marion(self.mqtt_client)
|
||||
self.gfw_dirk = ground_floor_west_dirk(self.mqtt_client)
|
||||
# first floor west
|
||||
self.ffw = first_floor_west(self.mqtt_client)
|
||||
self.ffw_julian = first_floor_west_julian(self.mqtt_client)
|
||||
self.ffw_living = first_floor_west_living(self.mqtt_client)
|
||||
self.ffw_bath = first_floor_west_bath(self.mqtt_client)
|
||||
# first floor east
|
||||
self.ffe = first_floor_east(self.mqtt_client)
|
||||
self.ffe_floor = first_floor_east_floor(self.mqtt_client)
|
||||
self.ffe_kitchen = first_floor_east_kitchen(self.mqtt_client)
|
||||
self.ffe_dining = first_floor_east_dining(self.mqtt_client)
|
||||
self.ffe_sleep = first_floor_east_sleep(self.mqtt_client)
|
||||
self.ffe_living = first_floor_east_living(self.mqtt_client)
|
||||
#
|
||||
# Interactions
|
||||
#
|
||||
@ -49,57 +47,82 @@ class all_functions(room_collection, devdi_rooms.collection):
|
||||
self.init_cross_room_interactions()
|
||||
# Off Buttons
|
||||
self.init_off_functionality()
|
||||
# Summer / Winter mode
|
||||
self.init_sumer_winter_mode()
|
||||
|
||||
def __stop_execution__(self, client, userdata, message):
|
||||
if config.DEBUG:
|
||||
try:
|
||||
data = json.loads(message.payload)
|
||||
except:
|
||||
logger.error("Error while receiving mqtt message: topic=%s - payload=%s", repr(message.topic), repr(message.payload))
|
||||
else:
|
||||
if data is True:
|
||||
self.run = False
|
||||
def init_off_functionality(self):
|
||||
# Off Buttons
|
||||
self.gui_button_all_off = devices.nodered_gui_button(self.mqtt_client, "gui/all/common/off/button")
|
||||
self.gui_button_gfw_off = devices.nodered_gui_button(self.mqtt_client, "gui/gfw/common/off/button")
|
||||
self.gui_button_ffw_off = devices.nodered_gui_button(self.mqtt_client, "gui/ffw/common/off/button")
|
||||
self.gui_button_ffe_off = devices.nodered_gui_button(self.mqtt_client, "gui/ffe/common/off/button")
|
||||
#
|
||||
self.gui_button_all_off.add_callback(devices.nodered_gui_button.KEY_STATE, True, self.all_off)
|
||||
self.gui_button_gfw_off.add_callback(devices.nodered_gui_button.KEY_STATE, True, self.gfw_off)
|
||||
self.gui_button_ffw_off.add_callback(devices.nodered_gui_button.KEY_STATE, True, self.ffw_off)
|
||||
self.gui_button_ffe_off.add_callback(devices.nodered_gui_button.KEY_STATE, True, self.ffe_off)
|
||||
# Long push ffe_floor
|
||||
self.ffe_floor.main_light_shelly.add_callback(devices.shelly.KEY_LONGPUSH_0, True, self.ffe_floor.all_off_feedback)
|
||||
self.ffe_floor.main_light_shelly.add_callback(devices.shelly.KEY_LONGPUSH_0, True, self.ffe_off)
|
||||
# Long push stairway
|
||||
self.stw_stairway.main_light_shelly.add_callback(devices.shelly.KEY_LONGPUSH_0, True, self.stw_stairway.all_off_feedback)
|
||||
self.stw_stairway.main_light_shelly.add_callback(devices.shelly.KEY_LONGPUSH_0, True, self.all_off)
|
||||
# Long push input device
|
||||
self.ffe_sleep.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_RIGHT_LONG, self.ffe_off)
|
||||
|
||||
def getmembers(self, prefix):
|
||||
rv = []
|
||||
for name, obj in inspect.getmembers(self):
|
||||
if name.startswith(prefix) and obj.__module__.split('.')[0] == 'function' and len(obj.__module__.split('.')) == 2:
|
||||
rv.append(obj)
|
||||
return rv
|
||||
|
||||
def common_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching \"common\" off.")
|
||||
for common in self.getmembers('common'):
|
||||
common.all_off()
|
||||
|
||||
def gfw_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching \"ground floor west\" off.")
|
||||
for gfw in self.getmembers('gfw'):
|
||||
gfw.all_off()
|
||||
|
||||
def ffw_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching \"first floor west\" off.")
|
||||
for ffw in self.getmembers('ffw'):
|
||||
ffw.all_off()
|
||||
|
||||
def ffe_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching \"first floor east\" off.")
|
||||
for ffe in self.getmembers('ffe'):
|
||||
ffe.all_off()
|
||||
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
self.common_off(device, key, data)
|
||||
self.gfw_off(device, key, data)
|
||||
self.ffw_off(device, key, data)
|
||||
self.ffe_off(device, key, data)
|
||||
|
||||
def init_cross_room_interactions(self):
|
||||
# shelly dirk input 1
|
||||
self.last_gfw_dirk_input_1 = None
|
||||
self.gfw.dirk.switch_main_light.add_callback(self.gfw.dirk.switch_main_light.KEY_INPUT_1, None, self.gfw_dirk_input_1)
|
||||
self.gfw_dirk.main_light_shelly.add_callback(devices.shelly.KEY_INPUT_1, None, self.gfw_dirk_input_1)
|
||||
# tradfri button ffe_sleep right click
|
||||
self.ffe.sleep.input_device.add_callback(self.ffe.sleep.input_device.KEY_ACTION,
|
||||
self.ffe.sleep.input_device.ACTION_RIGHT, self.ffe.floor.switch_main_light.toggle_output_0_mcb)
|
||||
|
||||
def init_off_functionality(self):
|
||||
# ALL OFF - Virtual device
|
||||
self.videv_all_off.connect_room_collection(self)
|
||||
|
||||
# ALL OFF - Long push stairway
|
||||
self.stw.stairway.switch_main_light.add_callback(self.stw.stairway.switch_main_light.KEY_LONGPUSH_0,
|
||||
True, self.stw.stairway.switch_main_light.flash_0_mcb)
|
||||
self.stw.stairway.switch_main_light.add_callback(self.stw.stairway.switch_main_light.KEY_LONGPUSH_0, True, self.all_off)
|
||||
|
||||
# FFE ALL OFF - Long push ffe_floor
|
||||
self.ffe.floor.switch_main_light.add_callback(self.ffe.floor.switch_main_light.KEY_LONGPUSH_0,
|
||||
True, self.ffe.floor.switch_main_light.flash_0_mcb)
|
||||
self.ffe.floor.switch_main_light.add_callback(self.ffe.floor.switch_main_light.KEY_LONGPUSH_0, True, self.ffe.all_off)
|
||||
|
||||
# FFE ALL OFF - Long push input device
|
||||
self.ffe.sleep.input_device.add_callback(self.ffe.sleep.input_device.KEY_ACTION,
|
||||
self.ffe.sleep.input_device.ACTION_RIGHT_LONG, self.ffe.all_off)
|
||||
|
||||
# FFW ALL OFF - Long push ffw_floor
|
||||
self.ffw.floor.switch_main_light.add_callback(self.ffw.floor.switch_main_light.KEY_LONGPUSH_0,
|
||||
True, self.ffw.floor.switch_main_light.flash_0_mcb)
|
||||
self.ffw.floor.switch_main_light.add_callback(self.ffw.floor.switch_main_light.KEY_LONGPUSH_0, True, self.ffw.all_off)
|
||||
|
||||
def init_sumer_winter_mode(self):
|
||||
self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.gfw.summer_mode)
|
||||
self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.ffw.summer_mode)
|
||||
self.videv_summer_mode.add_callback(self.videv_summer_mode.KEY_STATE, None, self.ffe.summer_mode)
|
||||
self.ffe_sleep.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION,
|
||||
devices.tradfri_button.ACTION_RIGHT, self.ffe_floor.main_light_shelly.toggle_output_0_mcb)
|
||||
|
||||
def gfw_dirk_input_1(self, device, key, data):
|
||||
if self.last_gfw_dirk_input_1 is not None:
|
||||
if self.last_gfw_dirk_input_1 != data:
|
||||
self.gfw.floor.switch_main_light.toggle_output_0_mcb(device, key, data)
|
||||
self.gfw_floor.main_light_shelly.toggle_output_0_mcb(device, key, data)
|
||||
self.last_gfw_dirk_input_1 = data
|
||||
|
||||
def devicelist(self):
|
||||
if self.__devices__ is None:
|
||||
self.__devices__ = []
|
||||
for name, obj in inspect.getmembers(self):
|
||||
if obj.__class__.__module__ == "devices":
|
||||
self.__devices__.append(obj)
|
||||
elif obj.__class__.__module__.split('.')[0] == 'function':
|
||||
for devicename, device in inspect.getmembers(obj):
|
||||
if device.__class__.__module__ == "devices":
|
||||
self.__devices__.append(device)
|
||||
return self.__devices__
|
||||
|
||||
@ -1,31 +1,15 @@
|
||||
from function.modules import heating_function
|
||||
import os
|
||||
import sqlite3
|
||||
|
||||
db_file = os.path.join(os.path.dirname(__file__), '..', 'database.db')
|
||||
|
||||
db_mapping_radiator = {
|
||||
0: heating_function.KEY_AWAY_MODE,
|
||||
1: heating_function.KEY_SUMMER_MODE,
|
||||
2: heating_function.KEY_USER_TEMPERATURE_SETPOINT,
|
||||
3: heating_function.KEY_TEMPERATURE_SETPOINT
|
||||
}
|
||||
|
||||
def get_gui_radiator_data(topic):
|
||||
return __storage__().get_gui_radiator_data(topic)
|
||||
|
||||
|
||||
def get_radiator_data(topic):
|
||||
db_data = __storage__().get_radiator_data(topic)
|
||||
rv = {}
|
||||
for index in db_mapping_radiator:
|
||||
rv[db_mapping_radiator[index]] = db_data[index]
|
||||
return rv
|
||||
|
||||
|
||||
def set_radiator_data(device, key, data):
|
||||
if key in db_mapping_radiator.values():
|
||||
db_data = []
|
||||
for index in range(0, len(db_mapping_radiator)):
|
||||
db_data.append(device.get(db_mapping_radiator[index]))
|
||||
return __storage__().store_radiator_data(device.heating_valve.topic, db_data)
|
||||
def set_gui_radiator_data(topic, away_mode, summer_mode, user_temperatur_setpoint):
|
||||
return __storage__().store_gui_radiator_data(topic, away_mode, summer_mode, user_temperatur_setpoint)
|
||||
|
||||
|
||||
class __storage__(object):
|
||||
@ -33,29 +17,30 @@ class __storage__(object):
|
||||
self.conn = sqlite3.connect(db_file)
|
||||
self.c = self.conn.cursor()
|
||||
with self.conn:
|
||||
self.c.execute("""CREATE TABLE IF NOT EXISTS radiator (
|
||||
self.c.execute("""CREATE TABLE IF NOT EXISTS gui_radiator (
|
||||
topic text PRIMARY KEY,
|
||||
away_mode integer,
|
||||
summer_mode integer,
|
||||
user_temperatur_setpoint real,
|
||||
temperatur_setpoint real
|
||||
user_temperatur_setpoint real
|
||||
)""")
|
||||
|
||||
def store_radiator_data(self, topic, target_data):
|
||||
def store_gui_radiator_data(self, topic, away_mode, summer_mode, user_temperatur_setpoint):
|
||||
data = [topic, away_mode, summer_mode, user_temperatur_setpoint]
|
||||
try:
|
||||
with self.conn:
|
||||
self.c.execute(
|
||||
'INSERT INTO radiator VALUES (?, ?, ?, ?, ?)', [topic] + target_data)
|
||||
'INSERT INTO gui_radiator VALUES (?, ?, ?, ?)', data)
|
||||
except sqlite3.IntegrityError:
|
||||
db_data = self.get_radiator_data(topic)
|
||||
if db_data != target_data:
|
||||
data = [away_mode, summer_mode, user_temperatur_setpoint]
|
||||
db_data = self.get_gui_radiator_data(topic)
|
||||
if db_data != data:
|
||||
with self.conn:
|
||||
self.c.execute(
|
||||
'UPDATE radiator SET away_mode = ?, summer_mode = ?, user_temperatur_setpoint = ?, temperatur_setpoint = ? WHERE topic = ?', target_data + [topic])
|
||||
'UPDATE gui_radiator SET away_mode = ?, summer_mode = ?, user_temperatur_setpoint = ? WHERE topic = ?', data + [topic])
|
||||
|
||||
def get_radiator_data(self, topic):
|
||||
""" returns a list [away_mode, summer_mode, user_temperatur_setpoint, temperatur_setpoint] or [None, None, None, None]"""
|
||||
self.c.execute("SELECT * FROM radiator WHERE topic=?", (topic, ))
|
||||
def get_gui_radiator_data(self, topic):
|
||||
""" returns a list [away_mode, summer_mode, user_temperatur_setpoint] or [None, None, None]"""
|
||||
self.c.execute("SELECT * FROM gui_radiator WHERE topic=?", (topic, ))
|
||||
data = self.c.fetchone()
|
||||
if data is not None:
|
||||
data = list(data)
|
||||
@ -63,7 +48,7 @@ class __storage__(object):
|
||||
data[2] = data[2] == 1
|
||||
return data[1:]
|
||||
else:
|
||||
return [None, None, None, None]
|
||||
return [None, None, None]
|
||||
|
||||
def __del__(self):
|
||||
self.conn.close()
|
||||
|
||||
@ -3,13 +3,10 @@
|
||||
#
|
||||
|
||||
import config
|
||||
from devdi import rooms
|
||||
from function.db import get_radiator_data, set_radiator_data
|
||||
from function.helpers import day_event
|
||||
from function.modules import brightness_choose_n_action, timer_on_activation, heating_function, switched_light
|
||||
from function.rooms import room, room_collection
|
||||
import devices
|
||||
from function.modules import brightness_choose_n_action, circulation_pump, radiator_function
|
||||
import logging
|
||||
|
||||
from function.rooms import room_shelly, room_shelly_motion_sensor, room_shelly_tradfri_light
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
except ImportError:
|
||||
@ -17,157 +14,141 @@ except ImportError:
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class first_floor_east(room_collection):
|
||||
def __init__(self, mqtt_client,):
|
||||
super().__init__(mqtt_client)
|
||||
self.dining = first_floor_east_dining(mqtt_client)
|
||||
self.floor = first_floor_east_floor(mqtt_client)
|
||||
self.kitchen = first_floor_east_kitchen(mqtt_client)
|
||||
self.livingroom = first_floor_east_living(mqtt_client)
|
||||
self.sleep = first_floor_east_sleep(mqtt_client)
|
||||
|
||||
|
||||
class first_floor_east_floor(rooms.ffe_floor, room):
|
||||
class first_floor_east_floor(room_shelly):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# connect videv and switch
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
# http://shelly1l-3C6105E4E629
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_FLOOR_MAIN_LIGHT_SHELLY, config.TOPIC_FFE_FLOOR_MAIN_LIGHT_GUI)
|
||||
|
||||
|
||||
class first_floor_east_kitchen(rooms.ffe_kitchen, room):
|
||||
class first_floor_east_kitchen(room_shelly):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
# http://shelly1l-8CAAB5616C01
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_KITCHEN_MAIN_LIGHT_SHELLY, config.TOPIC_FFE_KITCHEN_MAIN_LIGHT_GUI)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
self.circulation_pump = circulation_pump(mqtt_client)
|
||||
self.circulation_pump.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.flash_main_light)
|
||||
|
||||
# Request hue data of lead light after power on
|
||||
switched_light(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0, self.light_main_light)
|
||||
|
||||
# circulation pump
|
||||
self.circulation_pump = timer_on_activation(self.switch_circulation_pump, self.switch_circulation_pump.KEY_OUTPUT_0, 10*60)
|
||||
self.switch_circulation_pump.add_callback(self.switch_circulation_pump.KEY_OUTPUT_0, True, self.switch_main_light.flash_0_mcb, True)
|
||||
self.videv_circulation_pump.connect_sw_device(self.switch_circulation_pump, self.switch_circulation_pump.KEY_OUTPUT_0)
|
||||
self.videv_circulation_pump.connect_tm_device(self.circulation_pump, timer_on_activation.KEY_TIMER)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
self.circulation_pump.all_off(device, key, data)
|
||||
return super().all_off(device, key, data)
|
||||
|
||||
|
||||
class first_floor_east_dining(rooms.ffe_diningroom, room):
|
||||
class first_floor_east_dining(room_shelly):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
self.day_events = day_event((6, 0), (22, 0), 30, -30)
|
||||
self.day_events.add_callback(None, True, self.__day_events__, True)
|
||||
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_floor_light.connect_sw_device(self.switch_floor_light, self.switch_floor_light.KEY_OUTPUT_0)
|
||||
# http://shelly1l-84CCA8ADD055
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_DININGROOM_MAIN_LIGHT_SHELLY, config.TOPIC_FFE_DININGROOM_MAIN_LIGHT_GUI)
|
||||
self.floorlamp_powerplug = devices.silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_DININGROOM_FLOOR_LAMP_POWERPLUG)
|
||||
if config.CHRISTMAS:
|
||||
self.videv_garland_light.connect_sw_device(self.switch_garland_light, self.switch_garland_light.KEY_OUTPUT_0)
|
||||
self.garland_powerplug = devices.silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_DININGROOM_GARLAND_POWERPLUG)
|
||||
#
|
||||
self.gui_floorlamp = devices.nodered_gui_switch(mqtt_client, config.TOPIC_FFE_DININGROOM_FLOOR_LAMP_GUI)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.floorlamp_powerplug.set_output_0_mcb, True)
|
||||
self.gui_floorlamp.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.floorlamp_powerplug.set_output_0_mcb)
|
||||
self.floorlamp_powerplug.add_callback(devices.silvercrest_powerplug.KEY_OUTPUT_0, None, self.gui_floorlamp.set_state_mcb)
|
||||
|
||||
# main light -> floor_light
|
||||
self.switch_main_light.add_callback(self.switch_main_light.KEY_OUTPUT_0, None, self.switch_floor_light.set_output_0_mcb, True)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
# heating function <-> videv
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
|
||||
def __day_events__(self, device, key, data):
|
||||
if key in (self.day_events.KEY_SUNSET, self.day_events.KEY_START_OF_DAY):
|
||||
if config.CHRISTMAS:
|
||||
self.switch_garland_light.set_output_0(True)
|
||||
elif key in (self.day_events.KEY_START_OF_NIGHT, self.day_events.KEY_SUNRISE):
|
||||
if config.CHRISTMAS:
|
||||
self.switch_garland_light.set_output_0(False)
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
super().all_off(device, key, data)
|
||||
self.floorlamp_powerplug.set_output_0(False)
|
||||
if config.CHRISTMAS:
|
||||
self.garland_powerplug.set_output_0(False)
|
||||
|
||||
|
||||
class first_floor_east_sleep(rooms.ffe_sleep, room):
|
||||
class first_floor_east_sleep(room_shelly_tradfri_light):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
# http://shelly1l-E8DB84A254C7
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_SHELLY, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_GUI, config.TOPIC_FFE_SLEEP_MAIN_LIGHT_ZIGBEE)
|
||||
# bed light
|
||||
self.bed_light_di_tradfri = devices.tradfri_light(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_DI_ZIGBEE)
|
||||
self.gui_bed_light_di = devices.nodered_gui_light(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_DI_GUI)
|
||||
self.bed_light_ma_powerplug = devices.silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_MA_POWERPLUG)
|
||||
self.gui_bed_light_ma = devices.nodered_gui_switch(mqtt_client, config.TOPIC_FFE_SLEEP_BED_LIGHT_MA_GUI)
|
||||
#
|
||||
self.light_wardrobe_light.disable_all_off() # Always on - Off by light sensor
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
#
|
||||
self.videv_bed_dirk_light.connect_sw_device(self.light_bed_dirk_light, self.light_bed_dirk_light.KEY_OUTPUT_0)
|
||||
self.videv_bed_dirk_light.connect_br_device(self.light_bed_dirk_light, self.light_bed_dirk_light.KEY_BRIGHTNESS)
|
||||
#
|
||||
self.videv_bed_marion_light.connect_sw_device(self.switch_bed_marion_light, self.switch_bed_marion_light.KEY_OUTPUT_0)
|
||||
#
|
||||
self.videv_wardrobe_light.connect_sw_device(self.light_wardrobe_light, self.light_wardrobe_light.KEY_OUTPUT_0)
|
||||
self.videv_wardrobe_light.connect_br_device(self.light_wardrobe_light, self.light_wardrobe_light.KEY_BRIGHTNESS)
|
||||
|
||||
self.button_tradfri = devices.tradfri_button(mqtt_client, config.TOPIC_FFE_SLEEP_INPUT_DEVICE)
|
||||
# button / brightness function
|
||||
self.brightness_functions = brightness_choose_n_action(self.input_device)
|
||||
self.brightness_functions.add(self.light_main_light, self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.brightness_functions.add(self.light_bed_dirk_light, self.light_bed_dirk_light, self.light_bed_dirk_light.KEY_OUTPUT_0)
|
||||
# button / main light
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_TOGGLE, self.switch_main_light.toggle_output_0_mcb)
|
||||
# button / bed light
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_LEFT, self.light_bed_dirk_light.toggle_output_0_mcb)
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_LEFT_LONG,
|
||||
self.switch_bed_marion_light.toggle_output_0_mcb)
|
||||
# button
|
||||
self.videv_multistate.connect_br_function(self.brightness_functions, brightness_choose_n_action.KEY_ACTIVE_DEVICE, 2)
|
||||
self.brightness_functions = brightness_choose_n_action(mqtt_client, self.button_tradfri, config.TOPIC_FFE_SLEEP_DEVICE_CHOOSER_LED)
|
||||
self.brightness_functions.add(self.main_light_tradfri, self.main_light_shelly, devices.shelly.KEY_OUTPUT_0)
|
||||
self.brightness_functions.add(self.bed_light_di_tradfri, self.bed_light_di_tradfri, devices.tradfri_light.KEY_OUTPUT_0)
|
||||
# radiator valve
|
||||
self.radiator_function = radiator_function(mqtt_client, config.TOPIC_FFE_SLEEP_RADIATOR_VALVE_ZIGBEE,
|
||||
config.TOPIC_FFE_SLEEP_RADIATOR_VALVE_GUI, config.DEFAULT_TEMPERATURE_FFE_SLEEP)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
# on/off with button
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_TOGGLE,
|
||||
self.main_light_shelly.toggle_output_0_mcb)
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_LEFT,
|
||||
self.bed_light_di_tradfri.toggle_output_0_mcb)
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_LEFT_LONG,
|
||||
self.bed_light_ma_powerplug.toggle_output_0_mcb)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
# bed light
|
||||
# switch
|
||||
self.gui_bed_light_di.add_callback(devices.nodered_gui_light.KEY_STATE, None, self.bed_light_di_tradfri.set_output_0_mcb)
|
||||
self.bed_light_di_tradfri.add_callback(devices.tradfri_light.KEY_OUTPUT_0, None, self.gui_bed_light_di.set_state_mcb)
|
||||
self.gui_bed_light_ma.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.bed_light_ma_powerplug.set_output_0_mcb)
|
||||
self.bed_light_ma_powerplug.add_callback(devices.silvercrest_powerplug.KEY_OUTPUT_0, None, self.gui_bed_light_ma.set_state_mcb)
|
||||
# brightness and color temperature
|
||||
self.bed_light_di_tradfri.add_callback(devices.tradfri_light.KEY_OUTPUT_0, None, self.gui_bed_light_di.set_enable_mcb)
|
||||
self.gui_bed_light_di.add_callback(devices.nodered_gui_light.KEY_BRIGHTNESS, None, self.bed_light_di_tradfri.set_brightness_mcb)
|
||||
self.bed_light_di_tradfri.add_callback(devices.tradfri_light.KEY_OUTPUT_0, None, self.gui_bed_light_di.set_enable_mcb)
|
||||
self.bed_light_di_tradfri.add_callback(devices.tradfri_light.KEY_BRIGHTNESS, None, self.gui_bed_light_di.set_brightness_mcb)
|
||||
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
super().all_off(device, key, data)
|
||||
self.bed_light_di_tradfri.set_output_0(False)
|
||||
|
||||
|
||||
class first_floor_east_living(rooms.ffe_livingroom, room):
|
||||
class first_floor_east_living(room_shelly_tradfri_light):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
#
|
||||
self.videv_floor_light.connect_sw_device(self.light_floor_light, self.light_floor_light.KEY_OUTPUT_0)
|
||||
self.videv_floor_light.connect_br_device(self.light_floor_light, self.light_floor_light.KEY_BRIGHTNESS)
|
||||
self.videv_floor_light.connect_ct_device(self.light_floor_light, self.light_floor_light.KEY_COLOR_TEMP)
|
||||
# http://shelly1l-3C6105E3F910
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_SHELLY,
|
||||
config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_GUI, config.TOPIC_FFE_LIVINGROOM_MAIN_LIGHT_ZIGBEE)
|
||||
for i in range(1, 7):
|
||||
setattr(self, 'floorlamp_tradfri_%d' % i, devices.tradfri_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_FLOOR_LAMP_ZIGBEE % i))
|
||||
#
|
||||
if config.CHRISTMAS:
|
||||
self.videv_xmas_tree_light.connect_sw_device(self.switch_xmas_tree_light, self.switch_xmas_tree_light.KEY_OUTPUT_0)
|
||||
self.powerplug_xmas_tree = devices.silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_TREE_POWERPLUG)
|
||||
self.powerplug_xmas_star = devices.silvercrest_powerplug(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_STAR_POWERPLUG)
|
||||
#
|
||||
self.gui_floorlamp = devices.nodered_gui_light(mqtt_client, config.TOPIC_FFE_LIVINGROOM_FLOOR_LAMP_GUI)
|
||||
#
|
||||
if config.CHRISTMAS:
|
||||
self.gui_xmas_tree = devices.nodered_gui_switch(mqtt_client, config.TOPIC_FFE_LIVINGROOM_XMAS_TREE_GUI)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
|
||||
# main light -> floor_light
|
||||
self.switch_main_light.add_callback(self.switch_main_light.KEY_OUTPUT_0, None, self.light_floor_light.set_output_0_mcb, True)
|
||||
# floor lamp
|
||||
for device in self.__floorlamp_devices__():
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, device.set_output_0_mcb, True)
|
||||
self.gui_floorlamp.add_callback(devices.nodered_gui_light.KEY_STATE, None, device.set_output_0_mcb)
|
||||
self.gui_floorlamp.add_callback(devices.nodered_gui_light.KEY_BRIGHTNESS, None, device.set_brightness_mcb)
|
||||
self.gui_floorlamp.add_callback(devices.nodered_gui_light.KEY_COLOR_TEMP, None, device.set_color_temp_mcb)
|
||||
self.floorlamp_tradfri_1.add_callback(devices.tradfri_light.KEY_OUTPUT_0, None, self.gui_floorlamp.set_state_mcb)
|
||||
self.floorlamp_tradfri_1.add_callback(devices.tradfri_light.KEY_OUTPUT_0, None, self.gui_floorlamp.set_enable_mcb)
|
||||
self.floorlamp_tradfri_1.add_callback(devices.tradfri_light.KEY_BRIGHTNESS, None, self.gui_floorlamp.set_brightness_mcb)
|
||||
self.floorlamp_tradfri_1.add_callback(devices.tradfri_light.KEY_COLOR_TEMP, None, self.gui_floorlamp.set_color_temp_mcb)
|
||||
#
|
||||
if config.CHRISTMAS:
|
||||
self.powerplug_xmas_tree.add_callback(devices.silvercrest_powerplug.KEY_OUTPUT_0, None, self.gui_xmas_tree.set_state_mcb)
|
||||
self.gui_xmas_tree.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.powerplug_xmas_tree.set_output_0_mcb)
|
||||
#
|
||||
self.powerplug_xmas_tree.add_callback(devices.silvercrest_powerplug.KEY_OUTPUT_0, None, self.powerplug_xmas_star.set_output_0_mcb)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
super().all_off(device, key, data)
|
||||
for floorlamp in self.__floorlamp_devices__():
|
||||
floorlamp.set_output_0(False)
|
||||
if config.CHRISTMAS:
|
||||
self.powerplug_xmas_tree.set_output_0(False)
|
||||
self.powerplug_xmas_star.set_output_0(False)
|
||||
|
||||
def __floorlamp_devices__(self):
|
||||
rv = []
|
||||
for i in range(1, 7):
|
||||
rv.append(getattr(self, 'floorlamp_tradfri_%d' % i))
|
||||
return rv
|
||||
|
||||
@ -3,11 +3,9 @@
|
||||
#
|
||||
|
||||
import config
|
||||
from devdi import rooms
|
||||
from function.db import get_radiator_data, set_radiator_data
|
||||
from function.modules import heating_function
|
||||
from function.rooms import room, room_collection
|
||||
import logging
|
||||
from function.modules import radiator_function
|
||||
from function.rooms import room_shelly, room_shelly_tradfri_light
|
||||
|
||||
|
||||
try:
|
||||
@ -17,104 +15,20 @@ except ImportError:
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class first_floor_west(room_collection):
|
||||
class first_floor_west_julian(room_shelly_tradfri_light):
|
||||
# http://shelly1l-3C6105E43452
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
self.floor = first_floor_west_floor(mqtt_client)
|
||||
self.bath = first_floor_west_bath(mqtt_client)
|
||||
self.julian = first_floor_west_julian(mqtt_client)
|
||||
self.livingroom = first_floor_west_living(mqtt_client)
|
||||
self.sleep = first_floor_west_sleep(mqtt_client)
|
||||
super().__init__(mqtt_client, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_SHELLY, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_GUI, config.TOPIC_FFW_JULIAN_MAIN_LIGHT_ZIGBEE)
|
||||
|
||||
|
||||
class first_floor_west_floor(rooms.ffw_floor, room):
|
||||
class first_floor_west_living(room_shelly):
|
||||
# http://shelly1l-84CCA8ACE6A1
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# connect videv and switch
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
super().__init__(mqtt_client, config.TOPIC_FFW_LIVINGROOM_MAIN_LIGHT_SHELLY, config.TOPIC_FFW_LIVINGROOM_MAIN_LIGHT_GUI)
|
||||
|
||||
|
||||
class first_floor_west_julian(rooms.ffw_julian, room):
|
||||
class first_floor_west_bath(object):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
|
||||
|
||||
class first_floor_west_bath(rooms.ffw_bath, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
|
||||
|
||||
class first_floor_west_living(rooms.ffw_livingroom, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
|
||||
|
||||
class first_floor_west_sleep(rooms.ffw_sleep, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
#
|
||||
self.videv_window_light.connect_sw_device(self.light_window_light, self.light_window_light.KEY_OUTPUT_0)
|
||||
self.videv_window_light.connect_br_device(self.light_window_light, self.light_window_light.KEY_BRIGHTNESS)
|
||||
self.videv_window_light.connect_ct_device(self.light_window_light, self.light_window_light.KEY_COLOR_TEMP)
|
||||
|
||||
# main light -> window light
|
||||
self.switch_main_light.add_callback(self.switch_main_light.KEY_OUTPUT_0, None, self.light_window_light.set_output_0_mcb, True)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
# radiator valve
|
||||
self.radiator_function = radiator_function(mqtt_client, config.TOPIC_FFW_BATH_RADIATOR_VALVE_ZIGBEE,
|
||||
config.TOPIC_FFW_BATH_RADIATOR_VALVE_GUI, config.DEFAULT_TEMPERATURE_FFW_BATH)
|
||||
|
||||
@ -1,40 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
|
||||
from devdi import rooms
|
||||
from function.helpers import day_event
|
||||
from function.rooms import room, room_collection
|
||||
import logging
|
||||
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
except ImportError:
|
||||
ROOT_LOGGER_NAME = 'root'
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class garden(room_collection):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
self.garden = garden_garden(mqtt_client)
|
||||
|
||||
|
||||
class garden_garden(rooms.gar_garden, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
self.day_events = day_event((6, 0), (22, 0), 30, -30)
|
||||
self.day_events.add_callback(None, True, self.__day_events__, True)
|
||||
|
||||
# xxx <-> videv
|
||||
self.videv_garland_light.connect_sw_device(self.switch_garland_light, self.switch_garland_light.KEY_OUTPUT_0)
|
||||
self.videv_repeater.connect_sw_device(self.switch_repeater, self.switch_repeater.KEY_OUTPUT_0)
|
||||
|
||||
def __day_events__(self, device, key, data):
|
||||
if self.videv_mode.get(self.videv_mode.KEY_STATE):
|
||||
if key in (self.day_events.KEY_SUNSET, self.day_events.KEY_START_OF_DAY):
|
||||
self.switch_garland_light.set_output_0(True)
|
||||
elif key in (self.day_events.KEY_START_OF_NIGHT, self.day_events.KEY_SUNRISE):
|
||||
self.switch_garland_light.set_output_0(False)
|
||||
@ -3,11 +3,10 @@
|
||||
#
|
||||
|
||||
import config
|
||||
from devdi import rooms
|
||||
from function.db import get_radiator_data, set_radiator_data
|
||||
from function.modules import brightness_choose_n_action, heating_function, switched_light
|
||||
from function.rooms import room, room_collection
|
||||
import devices
|
||||
from function.modules import brightness_choose_n_action, radiator_function
|
||||
import logging
|
||||
from function.rooms import room_shelly, room_shelly_tradfri_light, room_shelly_silvercrest_light
|
||||
import task
|
||||
|
||||
try:
|
||||
@ -17,175 +16,158 @@ except ImportError:
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class ground_floor_west(room_collection):
|
||||
class ground_floor_west_floor(room_shelly_silvercrest_light):
|
||||
# http://shelly1l-84CCA8AD1148
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
self.dirk = ground_floor_west_dirk(mqtt_client)
|
||||
self.floor = ground_floor_west_floor(mqtt_client)
|
||||
self.marion = ground_floor_west_marion(mqtt_client)
|
||||
super().__init__(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_SHELLY, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_GUI, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_1_ZIGBEE)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.main_light_tradfri_2 = devices.tradfri_light(mqtt_client, config.TOPIC_GFW_FLOOR_MAIN_LIGHT_2_ZIGBEE)
|
||||
self.main_light_tradfri.add_callback(devices.tradfri_light.KEY_BRIGHTNESS, None, self.main_light_tradfri_2.set_brightness_mcb)
|
||||
self.main_light_tradfri.add_callback(devices.tradfri_light.KEY_COLOR_TEMP, None, self.main_light_tradfri_2.set_color_temp_mcb)
|
||||
|
||||
def send_init_message_main_light(self):
|
||||
super().send_init_message_main_light()
|
||||
self.main_light_tradfri_2.mqtt_client.send(self.main_light_tradfri_2.topic + "/get", '{"state": ""}')
|
||||
|
||||
|
||||
class ground_floor_west_dirk(rooms.gfw_dirk, room):
|
||||
class ground_floor_west_marion(room_shelly):
|
||||
# http://shelly1l-E8DB84A1E067
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client, config.TOPIC_GFW_MARION_MAIN_LIGHT_SHELLY, config.TOPIC_GFW_MARION_MAIN_LIGHT_GUI)
|
||||
# radiator valve
|
||||
self.radiator_function = radiator_function(mqtt_client, config.TOPIC_GFW_MARION_RADIATOR_VALVE_ZIGBEE,
|
||||
config.TOPIC_GFW_MARION_RADIATOR_VALVE_GUI, config.DEFAULT_TEMPERATURE_GFW_MARION)
|
||||
|
||||
|
||||
class ground_floor_west_dirk(room_shelly_tradfri_light):
|
||||
STATE_ACTIVE_DEVICE_MAIN_LIGHT = 0
|
||||
STATE_ACTIVE_DEVICE_DESK_LIGHT = 1
|
||||
STATE_ACTIVE_DEVICE_AMPLIFIER = 2
|
||||
STATE_ACTIVE_DEVICE_MAX_VALUE = STATE_ACTIVE_DEVICE_AMPLIFIER
|
||||
#
|
||||
LED_ACTIVE_DEVICE_MAIN_LIGHT = devices.nodered_gui_leds.KEY_LED_0
|
||||
LED_ACTIVE_DEVICE_DESK_LIGHT = devices.nodered_gui_leds.KEY_LED_1
|
||||
LED_ACTIVE_DEVICE_AMPLIFIER = devices.nodered_gui_leds.KEY_LED_2
|
||||
#
|
||||
KEY_POWERPLUG_AMPLIFIER = devices.my_powerplug.KEY_OUTPUT_0
|
||||
KEY_POWERPLUG_CD_PLAYER = devices.my_powerplug.KEY_OUTPUT_2
|
||||
KEY_POWERPLUG_DESK_LIGHT = devices.my_powerplug.KEY_OUTPUT_1
|
||||
KEY_POWERPLUG_PC_DOCK = devices.my_powerplug.KEY_OUTPUT_3
|
||||
#
|
||||
AUDIO_SOURCE_PC = 0
|
||||
AUDIO_SOURCE_CD = 1
|
||||
AUDIO_SOURCE_RASPI = 2
|
||||
AUDIO_SOURCE_BT = 3
|
||||
AUDIO_SOURCE_PHONO = 4
|
||||
|
||||
# http://shelly1l-3C6105E44F27
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
super().__init__(mqtt_client, config.TOPIC_GFW_DIRK_MAIN_LIGHT_SHELLY, config.TOPIC_GFW_DIRK_MAIN_LIGHT_GUI, config.TOPIC_GFW_DIRK_MAIN_LIGHT_ZIGBEE)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
self.powerplug_common = devices.my_powerplug(mqtt_client, config.TOPIC_GFW_DIRK_POWERPLUG)
|
||||
self.desk_light_tradfri = devices.tradfri_light(mqtt_client, config.TOPIC_GFW_DIRK_DESK_LIGHT_ZIGBEE)
|
||||
self.button_tradfri = devices.tradfri_button(mqtt_client, config.TOPIC_GFW_DIRK_INPUT_DEVICE)
|
||||
#
|
||||
self.videv_desk_light.connect_sw_device(self.light_desk_light, self.light_desk_light.KEY_OUTPUT_0)
|
||||
self.videv_desk_light.connect_br_device(self.light_desk_light, self.light_desk_light.KEY_BRIGHTNESS)
|
||||
self.videv_desk_light.connect_ct_device(self.light_desk_light, self.light_desk_light.KEY_COLOR_TEMP)
|
||||
self.gui_desk_light = devices.nodered_gui_light(mqtt_client, config.TOPIC_GFW_DIRK_DESK_LIGHT_GUI)
|
||||
#
|
||||
self.videv_amplifier.connect_sw_device(self.switch_powerplug_4, self.KEY_POWERPLUG_AMPLIFIER)
|
||||
self.videv_bluetooth.connect_sw_device(self.switch_powerplug_4, self.KEY_POWERPLUG_BT)
|
||||
self.videv_cd_player.connect_sw_device(self.switch_powerplug_4, self.KEY_POWERPLUG_CD_PLAYER)
|
||||
self.videv_phono.connect_sw_device(self.switch_powerplug_4, self.KEY_POWERPLUG_PHONO)
|
||||
self.gui_amplifier = devices.nodered_gui_switch(mqtt_client, config.TOPIC_GFW_DIRK_AMPLIFIER_GUI)
|
||||
self.gui_cd_player = devices.nodered_gui_switch(mqtt_client, config.TOPIC_GFW_DIRK_CD_PLAYER_GUI)
|
||||
self.gui_pc_dock = devices.nodered_gui_switch(mqtt_client, config.TOPIC_GFW_DIRK_PC_DOCK_GUI)
|
||||
#
|
||||
self.remote_amplifier = devices.remote(mqtt_client, config.TOPIC_GFW_DIRK_AMPLIFIER_REMOTE)
|
||||
#
|
||||
self.brightness_functions = brightness_choose_n_action(mqtt_client, self.button_tradfri, config.TOPIC_GFW_DIRK_DEVICE_CHOOSER_LED)
|
||||
self.brightness_functions.add(self.main_light_tradfri, self.main_light_shelly, devices.shelly.KEY_OUTPUT_0)
|
||||
self.brightness_functions.add(self.desk_light_tradfri, self.powerplug_common, self.KEY_POWERPLUG_DESK_LIGHT)
|
||||
self.brightness_functions.add(self.remote_amplifier, self.powerplug_common, self.KEY_POWERPLUG_AMPLIFIER)
|
||||
#
|
||||
self.spotify_state = devices.audio_status(mqtt_client, config.TOPIC_GFW_DIRK_SPOTIFY)
|
||||
self.mpd_state = devices.audio_status(mqtt_client, config.TOPIC_GFW_DIRK_MPD)
|
||||
# radiator valve
|
||||
self.radiator_function = radiator_function(mqtt_client, config.TOPIC_GFW_DIRK_RADIATOR_VALVE_ZIGBEE,
|
||||
config.TOPIC_GFW_DIRK_RADIATOR_VALVE_GUI, config.DEFAULT_TEMPERATURE_GFW_DIRK)
|
||||
#
|
||||
self.delayed_task = task.delayed(1.0, self.send_audio_source)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.videv_pc_dock.connect_sw_device(self.switch_pc_dock, self.switch_pc_dock.KEY_OUTPUT_0)
|
||||
|
||||
# amplifier on, if playing device on
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_PHONO, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_CD_PLAYER, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_BT, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
# amplifier on, if player on
|
||||
self.audio_status_bluetooth.add_callback(self.audio_status_bluetooth.KEY_STATE, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
self.audio_status_mpd.add_callback(self.audio_status_mpd.KEY_STATE, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
self.audio_status_spotify.add_callback(self.audio_status_spotify.KEY_STATE, None, self.switch_powerplug_4.set_output_0_mcb, True)
|
||||
# main light
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_TOGGLE,
|
||||
self.main_light_shelly.toggle_output_0_mcb)
|
||||
|
||||
# Audio source selection
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_AMPLIFIER, True, self.audio_source_selector, True)
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_CD_PLAYER, True, self.audio_source_selector, True)
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_BT, True, self.audio_source_selector, True)
|
||||
self.switch_powerplug_4.add_callback(self.KEY_POWERPLUG_PHONO, True, self.audio_source_selector, True)
|
||||
self.audio_status_bluetooth.add_callback(self.audio_status_bluetooth.KEY_STATE, True, self.audio_source_selector, True)
|
||||
self.audio_status_mpd.add_callback(self.audio_status_mpd.KEY_STATE, True, self.audio_source_selector, True)
|
||||
self.audio_status_spotify.add_callback(self.audio_status_spotify.KEY_STATE, True, self.audio_source_selector, True)
|
||||
# desk light
|
||||
# switch
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_RIGHT,
|
||||
self.powerplug_common.toggle_output_1_mcb)
|
||||
self.gui_desk_light.add_callback(devices.nodered_gui_light.KEY_STATE, None, self.powerplug_common.set_output_1_mcb)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_DESK_LIGHT, None, self.gui_desk_light.set_state_mcb)
|
||||
# brightness and color temp
|
||||
self.gui_desk_light.add_callback(devices.nodered_gui_light.KEY_BRIGHTNESS, None, self.desk_light_tradfri.set_brightness_mcb)
|
||||
self.gui_desk_light.add_callback(devices.nodered_gui_light.KEY_COLOR_TEMP, None, self.desk_light_tradfri.set_color_temp_mcb)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_DESK_LIGHT, None, self.gui_desk_light.set_enable_mcb)
|
||||
self.desk_light_tradfri.add_callback(devices.tradfri_light.KEY_BRIGHTNESS, None, self.gui_desk_light.set_brightness_mcb)
|
||||
self.desk_light_tradfri.add_callback(devices.tradfri_light.KEY_COLOR_TEMP, None, self.gui_desk_light.set_color_temp_mcb)
|
||||
|
||||
# amplifier
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_LEFT_LONG,
|
||||
self.powerplug_common.toggle_output_0_mcb)
|
||||
self.gui_amplifier.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.powerplug_common.set_output_0_mcb)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_AMPLIFIER, None, self.gui_amplifier.set_state_mcb)
|
||||
# amplifier auto on
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_CD_PLAYER, None, self.cd_amplifier_synchronisation, True)
|
||||
self.spotify_state.add_callback(devices.status.KEY_STATE, None, self.raspi_amplifier_synchronisation, True)
|
||||
self.mpd_state.add_callback(devices.status.KEY_STATE, None, self.raspi_amplifier_synchronisation, True)
|
||||
# audio source
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_AMPLIFIER, True, self.audio_source_selector, True)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_CD_PLAYER, True, self.audio_source_selector, True)
|
||||
self.spotify_state.add_callback(devices.status.KEY_STATE, True, self.audio_source_selector, True)
|
||||
self.mpd_state.add_callback(devices.status.KEY_STATE, True, self.audio_source_selector, True)
|
||||
self.audio_source = self.AUDIO_SOURCE_PC
|
||||
self.delayed_task_remote = task.delayed(1.0, self.send_audio_source)
|
||||
|
||||
# input device functions
|
||||
# Brightness functionality
|
||||
self.brightness_functions = brightness_choose_n_action(self.input_device)
|
||||
self.brightness_functions.add(self.light_main_light, self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.brightness_functions.add(self.light_desk_light, self.light_desk_light, self.light_desk_light.KEY_OUTPUT_0)
|
||||
self.brightness_functions.add(self.remote_ctrl, self.switch_powerplug_4, self.KEY_POWERPLUG_AMPLIFIER)
|
||||
# Button - Main light
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_TOGGLE,
|
||||
self.switch_main_light.toggle_output_0_mcb)
|
||||
# Button - Desk light
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_RIGHT,
|
||||
self.light_desk_light.toggle_output_0_mcb)
|
||||
# Button - Amplifier
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_LEFT_LONG,
|
||||
self.switch_powerplug_4.toggle_output_0_mcb)
|
||||
# Button - CD player
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_RIGHT_LONG,
|
||||
self.switch_powerplug_4.toggle_output_2_mcb)
|
||||
# Button - PC dock
|
||||
self.input_device.add_callback(self.input_device.KEY_ACTION, self.input_device.ACTION_LEFT,
|
||||
self.switch_pc_dock.toggle_output_0_mcb)
|
||||
# cd player
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_RIGHT_LONG,
|
||||
self.powerplug_common.toggle_output_2_mcb)
|
||||
self.gui_cd_player.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.powerplug_common.set_output_2_mcb)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_CD_PLAYER, None, self.gui_cd_player.set_state_mcb)
|
||||
|
||||
# additional videv connections
|
||||
self.videv_multistate.connect_br_function(self.brightness_functions, brightness_choose_n_action.KEY_ACTIVE_DEVICE, 3)
|
||||
#
|
||||
self.videv_audio_player.connect_audio_device(self.audio_status_bluetooth)
|
||||
self.videv_audio_player.connect_audio_device(self.audio_status_mpd)
|
||||
self.videv_audio_player.connect_audio_device(self.audio_status_spotify)
|
||||
# pc dock
|
||||
self.button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_LEFT,
|
||||
self.powerplug_common.toggle_output_3_mcb)
|
||||
self.gui_pc_dock.add_callback(devices.nodered_gui_switch.KEY_STATE, None, self.powerplug_common.set_output_3_mcb)
|
||||
self.powerplug_common.add_callback(self.KEY_POWERPLUG_PC_DOCK, None, self.gui_pc_dock.set_state_mcb)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
# heating function <-> videv
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
super().all_off(device, key, data)
|
||||
self.powerplug_common.set_output_all(False)
|
||||
|
||||
def cd_amplifier_synchronisation(self, device, key, data):
|
||||
logger.info("Syncing \"%s\" amplifier with cd player: %s", type(self).__name__, data)
|
||||
self.powerplug_common.set_output(self.KEY_POWERPLUG_AMPLIFIER, data)
|
||||
|
||||
def raspi_amplifier_synchronisation(self, device, key, data):
|
||||
logger.info("Syncing \"%s\" amplifier with raspi player: %s", type(self).__name__, data)
|
||||
self.powerplug_common.set_output(self.KEY_POWERPLUG_AMPLIFIER, data)
|
||||
|
||||
def audio_source_selector(self, device, key, data):
|
||||
if device == self.switch_powerplug_4 and key == self.KEY_POWERPLUG_CD_PLAYER:
|
||||
if device == self.powerplug_common and key == self.KEY_POWERPLUG_CD_PLAYER:
|
||||
# switch on of cd player
|
||||
self.audio_source = self.AUDIO_SOURCE_CD
|
||||
elif device == self.switch_powerplug_4 and key == self.KEY_POWERPLUG_BT:
|
||||
# switch on of bluetooth
|
||||
self.audio_source = self.AUDIO_SOURCE_BT
|
||||
elif device == self.switch_powerplug_4 and key == self.KEY_POWERPLUG_PHONO:
|
||||
# switch on of bluetooth
|
||||
self.audio_source = self.AUDIO_SOURCE_PHONO
|
||||
elif device in [self.audio_status_spotify, self.audio_status_mpd, self.audio_status_bluetooth]:
|
||||
elif device in [self.spotify_state, self.mpd_state]:
|
||||
# switch on raspi-source
|
||||
self.audio_source = self.AUDIO_SOURCE_RASPI
|
||||
elif device == self.switch_powerplug_4 and key == self.KEY_POWERPLUG_AMPLIFIER:
|
||||
elif device == self.powerplug_common and key == self.KEY_POWERPLUG_AMPLIFIER:
|
||||
# switch on of amplifier -> select source and reset stored source value
|
||||
self.delayed_task_remote.run()
|
||||
self.delayed_task.run()
|
||||
|
||||
def send_audio_source(self):
|
||||
if self.audio_source == self.AUDIO_SOURCE_PC:
|
||||
logger.info("Sending IR command to change audio source to pc")
|
||||
self.remote_ctrl.set_line3()
|
||||
self.remote_amplifier.set_line3()
|
||||
elif self.audio_source == self.AUDIO_SOURCE_CD:
|
||||
logger.info("Sending IR command to change audio source to cd")
|
||||
self.remote_ctrl.set_cd()
|
||||
elif self.audio_source == self.AUDIO_SOURCE_BT:
|
||||
logger.info("Sending IR command to change audio source to bluetooth")
|
||||
self.remote_ctrl.set_line2()
|
||||
elif self.audio_source == self.AUDIO_SOURCE_PHONO:
|
||||
logger.info("Sending IR command to change audio source to phono")
|
||||
self.remote_ctrl.set_phono()
|
||||
self.remote_amplifier.set_cd()
|
||||
elif self.audio_source == self.AUDIO_SOURCE_RASPI:
|
||||
logger.info("Sending IR command to change audio source to raspi")
|
||||
self.remote_ctrl.set_line1()
|
||||
self.remote_amplifier.set_line1()
|
||||
self.audio_source = self.AUDIO_SOURCE_PC
|
||||
|
||||
|
||||
class ground_floor_west_floor(rooms.gfw_floor, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# Request silvercrest data of lead light after power on
|
||||
switched_light(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0, self.light_main_light)
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
self.videv_main_light.connect_br_device(self.light_main_light, self.light_main_light.KEY_BRIGHTNESS)
|
||||
self.videv_main_light.connect_ct_device(self.light_main_light, self.light_main_light.KEY_COLOR_TEMP)
|
||||
|
||||
|
||||
class ground_floor_west_marion(rooms.gfw_marion, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# light <-> videv
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
#
|
||||
self.videv_window_light.connect_sw_device(self.light_window_light, self.light_window_light.KEY_OUTPUT_0)
|
||||
self.videv_window_light.connect_br_device(self.light_window_light, self.light_window_light.KEY_BRIGHTNESS)
|
||||
self.videv_window_light.connect_ct_device(self.light_window_light, self.light_window_light.KEY_COLOR_TEMP)
|
||||
|
||||
# main light -> window_light
|
||||
self.switch_main_light.add_callback(self.switch_main_light.KEY_OUTPUT_0, None, self.light_window_light.set_output_0_mcb, True)
|
||||
|
||||
# heating function
|
||||
self.heating_function = heating_function(
|
||||
self.valve_heating,
|
||||
config.DEFAULT_TEMPERATURE,
|
||||
**get_radiator_data(self.valve_heating.topic)
|
||||
)
|
||||
self.heating_function.add_callback(None, None, set_radiator_data, True)
|
||||
# heating function <-> videv
|
||||
self.videv_heating.connect_heating_function(self.heating_function)
|
||||
|
||||
@ -1,10 +1,9 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
from mqtt.smarthome import common_base
|
||||
import config
|
||||
import geo
|
||||
import task
|
||||
import inspect
|
||||
import time
|
||||
|
||||
|
||||
@ -12,104 +11,9 @@ def now():
|
||||
return time.mktime(time.localtime())
|
||||
|
||||
|
||||
def next_sunrise_time(time_offs_min=30):
|
||||
tm = now()
|
||||
rv = time.mktime(geo.sun.sunrise(config.GEO_POSITION)) + time_offs_min * 60
|
||||
if tm > rv:
|
||||
rv = time.mktime(geo.sun.sunrise(config.GEO_POSITION, date=time.localtime(tm + 24 * 60 * 60))) + time_offs_min * 60
|
||||
return rv
|
||||
def sunrise_time(time_offs_min=30):
|
||||
return time.mktime(geo.sun.sunrise(config.GEO_POSITION)) + time_offs_min * 60
|
||||
|
||||
|
||||
def next_sunset_time(time_offs_min=-30):
|
||||
tm = now()
|
||||
rv = time.mktime(geo.sun.sunset(config.GEO_POSITION)) + time_offs_min * 60
|
||||
if tm > rv:
|
||||
rv = time.mktime(geo.sun.sunset(config.GEO_POSITION, date=time.localtime(tm + 24 * 60 * 60))) + time_offs_min * 60
|
||||
return rv
|
||||
|
||||
|
||||
def next_user_time(hh, mm):
|
||||
ts = time.localtime()
|
||||
tm = time.mktime(ts)
|
||||
ut_ts = list(ts)
|
||||
ut_ts[3] = hh
|
||||
ut_ts[4] = mm
|
||||
ut = time.mktime(time.struct_time(list(ts[:3]) + [hh, mm, 0] + list(ts[6:])))
|
||||
if ts[3] > hh or (ts[3] == hh and ts[4] >= mm):
|
||||
ut += 24 * 60 * 60
|
||||
#
|
||||
return ut
|
||||
|
||||
|
||||
class day_state(common_base):
|
||||
"""
|
||||
Class to subscribe day events as a callback (see add_callback)
|
||||
|
||||
:param time_start_of_day: Time of a day (tuple including hour and minute) for start of day or None for no start of day state.
|
||||
:type time_start_of_day: tuple
|
||||
:param time_start_of_night: Time of a day (tuple including hour and minute) for start of night or None for no end of day state.
|
||||
:type time_start_of_night: tuple
|
||||
:param time_offset_sunrise: time offset for sunrise in minutes (negative values lead to earlier sunrise state) or None for no sunrise state.
|
||||
:type time_start_of_day: int
|
||||
:param time_offset_sunset: time offset for sunset in minutes (negative values lead to earlier sunset state) or None for no sunrise state.
|
||||
:type time_start_of_day: int
|
||||
"""
|
||||
KEY_SUNRISE = 'sunrise'
|
||||
KEY_SUNSET = 'sunset'
|
||||
KEY_START_OF_NIGHT = 'start_of_night'
|
||||
KEY_START_OF_DAY = 'start_of_day'
|
||||
#
|
||||
STATES = (KEY_START_OF_DAY, KEY_SUNRISE, KEY_SUNSET, KEY_START_OF_NIGHT)
|
||||
|
||||
def __init__(self, time_start_of_day, time_start_of_night, time_offset_sunrise, time_offset_sunset):
|
||||
self.__time_start_of_day__ = time_start_of_day
|
||||
self.__time_start_of_night__ = time_start_of_night
|
||||
self.__time_offset_sunrise__ = time_offset_sunrise
|
||||
self.__time_offset_sunset__ = time_offset_sunset
|
||||
super().__init__()
|
||||
#
|
||||
|
||||
def get_state(self):
|
||||
tm = {}
|
||||
if self.__time_offset_sunrise__ is not None:
|
||||
tm[next_sunrise_time(self.__time_offset_sunrise__)] = self.KEY_SUNRISE
|
||||
if self.__time_start_of_day__ is not None:
|
||||
tm[next_user_time(*(self.__time_start_of_day__))] = self.KEY_START_OF_DAY
|
||||
if self.__time_offset_sunset__ is not None:
|
||||
tm[next_sunset_time(self.__time_offset_sunset__)] = self.KEY_SUNSET
|
||||
if self.__time_start_of_night__ is not None:
|
||||
tm[next_user_time(*(self.__time_start_of_night__))] = self.KEY_START_OF_NIGHT
|
||||
#
|
||||
tms = list(tm.keys())
|
||||
tms.sort()
|
||||
return tm[tms[-1]]
|
||||
|
||||
|
||||
class day_event(day_state):
|
||||
"""
|
||||
Class to subscribe day events as a callback (see add_callback)
|
||||
|
||||
:param time_start_of_day: Time of a day (tuple including hour and minute) for start of day or None for no start of day state.
|
||||
:type time_start_of_day: tuple
|
||||
:param time_start_of_night: Time of a day (tuple including hour and minute) for start of night or None for no end of day state.
|
||||
:type time_start_of_night: tuple
|
||||
:param time_offset_sunrise: time offset for sunrise in seconds (negative values lead to earlier sunrise state) or None for no sunrise state.
|
||||
:type time_start_of_day: int
|
||||
:param time_offset_sunset: time offset for sunset in seconds (negative values lead to earlier sunset state) or None for no sunrise state.
|
||||
:type time_start_of_day: int
|
||||
"""
|
||||
|
||||
def __init__(self, time_start_of_day=(5, 0), time_start_of_night=(22, 0), time_offset_sunrise=30, time_offset_sunset=-30):
|
||||
super().__init__(time_start_of_day, time_start_of_night, time_offset_sunrise, time_offset_sunset)
|
||||
#
|
||||
current_day_state = self.get_state()
|
||||
for key in self.STATES:
|
||||
self[key] = current_day_state == key
|
||||
#
|
||||
cyclic = task.periodic(30, self.__cyclic__)
|
||||
cyclic.run()
|
||||
|
||||
def __cyclic__(self, a):
|
||||
current_day_state = self.get_state()
|
||||
for key in self.STATES:
|
||||
self.set(key, current_day_state == key)
|
||||
def sunset_time(time_offs_min=-30):
|
||||
return time.mktime(geo.sun.sunset(config.GEO_POSITION)) + time_offs_min * 60
|
||||
|
||||
@ -1,22 +1,13 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
"""
|
||||
Functional Modules
|
||||
|
||||
Targets:
|
||||
* Device like structure to be compatible with videv
|
||||
- KEY_* as part of the class for all parameters which needs to be accessed from videv
|
||||
- Method *.set(key, data) to pass data from videv to Module
|
||||
- Method .add_calback(key, data, callback, on_change_only=False) to register videv actualisation on changes
|
||||
"""
|
||||
|
||||
from mqtt.smarthome import common_base
|
||||
import config
|
||||
import devices
|
||||
from function.helpers import day_state
|
||||
from function.db import get_gui_radiator_data, set_gui_radiator_data
|
||||
from function.rooms import room_shelly
|
||||
import logging
|
||||
import task
|
||||
import time
|
||||
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
@ -25,30 +16,26 @@ except ImportError:
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class switched_light(object):
|
||||
def __init__(self, sw_device, sw_key, li_device):
|
||||
sw_device.add_callback(sw_device.KEY_OUTPUT_0, True, li_device.request_data, True)
|
||||
|
||||
|
||||
class brightness_choose_n_action(common_base):
|
||||
KEY_ACTIVE_DEVICE = 'active_device'
|
||||
#
|
||||
DEFAULT_VALUES = {KEY_ACTIVE_DEVICE: None}
|
||||
|
||||
def __init__(self, button_tradfri):
|
||||
super().__init__()
|
||||
class brightness_choose_n_action(object):
|
||||
def __init__(self, mqtt_client, button_tradfri, topic_led):
|
||||
self.gui_led_active_device = devices.nodered_gui_leds(mqtt_client, topic_led)
|
||||
# brightness change
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_DOWN_LONG, self.brightness_action)
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_UP_LONG, self.brightness_action)
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_DOWN_RELEASE, self.brightness_action)
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_UP_RELEASE, self.brightness_action)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION,
|
||||
devices.tradfri_button.ACTION_BRIGHTNESS_DOWN_LONG, self.brightness_action)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_BRIGHTNESS_UP_LONG, self.brightness_action)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION,
|
||||
devices.tradfri_button.ACTION_BRIGHTNESS_DOWN_RELEASE, self.brightness_action)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION,
|
||||
devices.tradfri_button.ACTION_BRIGHTNESS_UP_RELEASE, self.brightness_action)
|
||||
# device change
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_UP, self.choose_next_device)
|
||||
button_tradfri.add_callback(button_tradfri.KEY_ACTION, button_tradfri.ACTION_BRIGHTNESS_DOWN, self.choose_prev_device)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_BRIGHTNESS_UP, self.choose_next_device)
|
||||
button_tradfri.add_callback(devices.tradfri_button.KEY_ACTION, devices.tradfri_button.ACTION_BRIGHTNESS_DOWN, self.choose_prev_device)
|
||||
#
|
||||
self.brightness_device_list = []
|
||||
self.callback_device_list = []
|
||||
self.device_states = []
|
||||
self.active_device_state = None
|
||||
self.update_active_device_led()
|
||||
|
||||
def add(self, brightness_device, callback_device, callback_key):
|
||||
"""
|
||||
@ -59,6 +46,8 @@ class brightness_choose_n_action(common_base):
|
||||
callback_device: A device for installing callback which are executed, when the device is switched on or off. It needs the following method:
|
||||
* .add_callback(key, data or None, callback, on_changes_only)
|
||||
"""
|
||||
if len(self.brightness_device_list) >= len(devices.nodered_gui_leds.KEY_LED_LIST):
|
||||
raise ValueError("Number of devices is limited by number of leds in devices.nodered_gui_leds.")
|
||||
self.brightness_device_list.append(brightness_device)
|
||||
self.callback_device_list.append((callback_device, callback_key))
|
||||
self.device_states.append(False)
|
||||
@ -68,35 +57,42 @@ class brightness_choose_n_action(common_base):
|
||||
def device_state_action(self, device, key, data):
|
||||
self.device_states[self.callback_device_list.index((device, key))] = data
|
||||
if data is True:
|
||||
self.set(self.KEY_ACTIVE_DEVICE, self.callback_device_list.index((device, key)))
|
||||
self.active_device_state = self.callback_device_list.index((device, key))
|
||||
self.update_active_device_led()
|
||||
else:
|
||||
if self[self.KEY_ACTIVE_DEVICE] is not None:
|
||||
if self.callback_device_list[self[self.KEY_ACTIVE_DEVICE]][0] == device:
|
||||
self.choose_next_device()
|
||||
self.choose_next_device()
|
||||
|
||||
def update_active_device_led(self):
|
||||
for i in range(0, len(self.brightness_device_list)):
|
||||
self.gui_led_active_device.set_led(devices.nodered_gui_leds.KEY_LED_LIST[i], self.active_device_state == i)
|
||||
|
||||
def choose_prev_device(self, device=None, key=None, data=None):
|
||||
if self[self.KEY_ACTIVE_DEVICE] is not None:
|
||||
start_value = self[self.KEY_ACTIVE_DEVICE]
|
||||
if self.active_device_state is not None:
|
||||
start_value = self.active_device_state
|
||||
for i in range(0, len(self.brightness_device_list)):
|
||||
target_state = (start_value - i - 1) % (len(self.brightness_device_list))
|
||||
if self.device_states[target_state]:
|
||||
self.set(self.KEY_ACTIVE_DEVICE, target_state)
|
||||
self.active_device_state = target_state
|
||||
self.update_active_device_led()
|
||||
return
|
||||
self.set(self.KEY_ACTIVE_DEVICE, None)
|
||||
self.active_device_state = None
|
||||
self.update_active_device_led()
|
||||
|
||||
def choose_next_device(self, device=None, key=None, data=None):
|
||||
if self[self.KEY_ACTIVE_DEVICE] is not None:
|
||||
start_value = self[self.KEY_ACTIVE_DEVICE]
|
||||
if self.active_device_state is not None:
|
||||
start_value = self.active_device_state
|
||||
for i in range(0, len(self.brightness_device_list)):
|
||||
target_state = (start_value + i + 1) % (len(self.brightness_device_list))
|
||||
if self.device_states[target_state]:
|
||||
self.set(self.KEY_ACTIVE_DEVICE, target_state)
|
||||
self.active_device_state = target_state
|
||||
self.update_active_device_led()
|
||||
return
|
||||
self.set(self.KEY_ACTIVE_DEVICE, None)
|
||||
self.active_device_state = None
|
||||
self.update_active_device_led()
|
||||
|
||||
def brightness_action(self, device, key, data):
|
||||
if self[self.KEY_ACTIVE_DEVICE] is not None:
|
||||
target = self.brightness_device_list[self[self.KEY_ACTIVE_DEVICE]]
|
||||
if self.active_device_state is not None:
|
||||
target = self.brightness_device_list[self.active_device_state]
|
||||
if data == devices.tradfri_button.ACTION_BRIGHTNESS_UP_LONG:
|
||||
logger.info("Increasing \"%s\" - %s", type(self).__name__, target.topic)
|
||||
target.default_inc()
|
||||
@ -107,239 +103,140 @@ class brightness_choose_n_action(common_base):
|
||||
target.default_stop()
|
||||
|
||||
|
||||
class timer_on_activation(common_base):
|
||||
KEY_TIMER = 'timer'
|
||||
#
|
||||
DEFAULT_VALUES = {
|
||||
KEY_TIMER: 0
|
||||
}
|
||||
|
||||
def __init__(self, sw_device, sw_key, timer_reload_value):
|
||||
super().__init__()
|
||||
class circulation_pump(room_shelly):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client, config.TOPIC_FFE_KITCHEN_CIRCULATION_PUMP_SHELLY, config.TOPIC_FFE_KITCHEN_CIRCULATION_PUMP_GUI)
|
||||
#
|
||||
self.timer_reload_value = timer_reload_value
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.circ_pump_actions, True)
|
||||
#
|
||||
sw_device.add_callback(sw_key, None, self.circ_pump_actions, True)
|
||||
self.gui_main_light.set_timer('-')
|
||||
#
|
||||
self.ct = task.periodic(6, self.cyclic_task)
|
||||
self.pump_timer = None
|
||||
#
|
||||
self.ct.run()
|
||||
|
||||
def circ_pump_actions(self, device, key, data):
|
||||
if data is True:
|
||||
self.set(self.KEY_TIMER, self.timer_reload_value)
|
||||
self.pump_timer = 10
|
||||
self.gui_main_light.set_timer(self.pump_timer)
|
||||
else:
|
||||
self.set(self.KEY_TIMER, 0)
|
||||
self.pump_timer = None
|
||||
self.gui_main_light.set_timer('-')
|
||||
|
||||
def cyclic_task(self, rt):
|
||||
timer_value = self[self.KEY_TIMER] - self.ct.cycle_time
|
||||
if timer_value <= 0:
|
||||
self.set(self.KEY_TIMER, 0)
|
||||
else:
|
||||
self.set(self.KEY_TIMER, timer_value)
|
||||
if self.pump_timer is not None:
|
||||
if self.pump_timer <= 0:
|
||||
self.pump_timer = None
|
||||
self.gui_main_light.set_timer('-')
|
||||
else:
|
||||
self.gui_main_light.set_timer(self.pump_timer)
|
||||
self.pump_timer -= self.ct.cycle_time / 60
|
||||
|
||||
|
||||
class heating_function(common_base):
|
||||
KEY_USER_TEMPERATURE_SETPOINT = 'user_temperature_setpoint'
|
||||
KEY_TEMPERATURE_SETPOINT = 'temperature_setpoint'
|
||||
KEY_TEMPERATURE_CURRENT = 'temperature_current'
|
||||
KEY_AWAY_MODE = 'away_mode'
|
||||
KEY_SUMMER_MODE = 'summer_mode'
|
||||
KEY_START_BOOST = 'start_boost'
|
||||
KEY_SET_DEFAULT_TEMPERATURE = 'set_default_temperature'
|
||||
KEY_BOOST_TIMER = 'boost_timer'
|
||||
#
|
||||
class radiator_function(object):
|
||||
BOOST_TEMPERATURE = 30
|
||||
AWAY_REDUCTION = 5
|
||||
SUMMER_TEMPERATURE = 5
|
||||
|
||||
class value_timeout_list(object):
|
||||
MAX_DELAY = 10
|
||||
|
||||
def __init__(self):
|
||||
self.__data__ = []
|
||||
self.__time__ = []
|
||||
|
||||
def __cleanup__(self):
|
||||
now = time.time()
|
||||
for i, tm in enumerate(self.__time__):
|
||||
if tm + self.MAX_DELAY < now:
|
||||
del (self.__data__[i])
|
||||
del (self.__time__[i])
|
||||
|
||||
def new(self, item):
|
||||
self.__cleanup__()
|
||||
self.__data__.append(item)
|
||||
self.__time__.append(time.time())
|
||||
|
||||
def is_valid_value(self, data):
|
||||
self.__cleanup__()
|
||||
return data not in self.__data__
|
||||
|
||||
def __init__(self, heating_valve, default_temperature, **kwargs):
|
||||
self.heating_valve = heating_valve
|
||||
def __init__(self, mqtt_client, topic_valve, topic_gui, default_temperature):
|
||||
self.default_temperature = default_temperature
|
||||
self.boost_timer = None
|
||||
# device initialisation
|
||||
self.heating_valve = devices.brennenstuhl_heatingvalve(mqtt_client, topic_valve)
|
||||
self.gui_heating = devices.nodered_gui_radiator(mqtt_client, topic_gui)
|
||||
# db-stored data initialisation
|
||||
db_data = get_gui_radiator_data(topic_gui)
|
||||
self.__away_mode__ = db_data[0] or False
|
||||
self.__summer_mode__ = db_data[1] or False
|
||||
self.__user_temperature_setpoint__ = db_data[2] or default_temperature
|
||||
if self.__away_mode__:
|
||||
self.away_mode(None, None, True)
|
||||
elif self.__summer_mode__:
|
||||
self.summer_mode(None, None, True)
|
||||
else:
|
||||
self.set_heating_setpoint(None, None, self.__user_temperature_setpoint__)
|
||||
# callback initialisation
|
||||
self.heating_valve.add_callback(devices.brennenstuhl_heatingvalve.KEY_TEMPERATURE, None, self.gui_heating.set_temperature_mcb)
|
||||
self.heating_valve.add_callback(devices.brennenstuhl_heatingvalve.KEY_HEATING_SETPOINT, None, self.get_radiator_setpoint)
|
||||
#
|
||||
self.valve_value = self.value_timeout_list()
|
||||
#
|
||||
super().__init__({
|
||||
self.KEY_USER_TEMPERATURE_SETPOINT: kwargs.get(self.KEY_USER_TEMPERATURE_SETPOINT, self.default_temperature),
|
||||
self.KEY_TEMPERATURE_SETPOINT: kwargs.get(self.KEY_TEMPERATURE_SETPOINT, self.default_temperature),
|
||||
self.KEY_TEMPERATURE_CURRENT: kwargs.get(self.KEY_TEMPERATURE_CURRENT, None),
|
||||
self.KEY_AWAY_MODE: kwargs.get(self.KEY_AWAY_MODE, False),
|
||||
self.KEY_SUMMER_MODE: kwargs.get(self.KEY_SUMMER_MODE, False),
|
||||
self.KEY_START_BOOST: kwargs.get(self.KEY_START_BOOST, True),
|
||||
self.KEY_SET_DEFAULT_TEMPERATURE: kwargs.get(self.KEY_SET_DEFAULT_TEMPERATURE, False),
|
||||
self.KEY_BOOST_TIMER: kwargs.get(self.KEY_BOOST_TIMER, 0)
|
||||
})
|
||||
#
|
||||
self.heating_valve.set_heating_setpoint(self[self.KEY_TEMPERATURE_SETPOINT])
|
||||
#
|
||||
self.heating_valve.add_callback(self.heating_valve.KEY_HEATING_SETPOINT, None, self.get_radiator_setpoint)
|
||||
self.heating_valve.add_callback(self.heating_valve.KEY_TEMPERATURE, None, self.get_radiator_temperature)
|
||||
#
|
||||
self.add_callback(self.KEY_USER_TEMPERATURE_SETPOINT, None, self.user_temperature_setpoint, False)
|
||||
self.add_callback(self.KEY_TEMPERATURE_SETPOINT, None, self.set_heating_setpoint, True)
|
||||
self.add_callback(self.KEY_AWAY_MODE, None, self.away_mode, True)
|
||||
self.add_callback(self.KEY_SUMMER_MODE, None, self.summer_mode, True)
|
||||
self.add_callback(self.KEY_SET_DEFAULT_TEMPERATURE, None, self.setpoint_to_default)
|
||||
self.add_callback(self.KEY_START_BOOST, True, self.boost, False)
|
||||
self.add_callback(self.KEY_BOOST_TIMER, 0, self.timer_expired, True)
|
||||
self.gui_heating.add_callback(devices.nodered_gui_radiator.KEY_SETPOINT_TEMP, None, self.set_heating_setpoint)
|
||||
self.gui_heating.add_callback(devices.nodered_gui_radiator.KEY_BOOST, None, self.boost)
|
||||
self.gui_heating.add_callback(devices.nodered_gui_radiator.KEY_SETPOINT_TO_DEFAULT, None, self.setpoint_to_default)
|
||||
self.gui_heating.add_callback(devices.nodered_gui_radiator.KEY_AWAY, None, self.away_mode)
|
||||
self.gui_heating.add_callback(devices.nodered_gui_radiator.KEY_SUMMER, None, self.summer_mode)
|
||||
# cyclic task initialisation
|
||||
self.ct = task.periodic(1, self.cyclic_task)
|
||||
self.ct.run()
|
||||
|
||||
def timer_expired(self, device, data, key):
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self[self.KEY_USER_TEMPERATURE_SETPOINT])
|
||||
self.heating_valve.logger.info('Timer expired. returning to regular temperature setpoint %.1f°C.',
|
||||
self[self.KEY_TEMPERATURE_SETPOINT])
|
||||
|
||||
def cyclic_task(self, rt):
|
||||
timer_value = self[self.KEY_BOOST_TIMER] - self.ct.cycle_time
|
||||
if self[self.KEY_BOOST_TIMER] <= 0:
|
||||
self.set(self.KEY_BOOST_TIMER, 0)
|
||||
else:
|
||||
self.set(self.KEY_BOOST_TIMER, timer_value)
|
||||
if self.boost_timer is not None:
|
||||
self.gui_heating.set_timer(round(self.boost_timer / 60, 1))
|
||||
#
|
||||
self.boost_timer -= self.ct.cycle_time
|
||||
if self.boost_timer <= 0:
|
||||
self.cancel_boost()
|
||||
self.heating_valve.set_heating_setpoint(self.__user_temperature_setpoint__)
|
||||
self.heating_valve.logger.info('Timer expired. returning to regular temperature setpoint %.1f°C.', self.__user_temperature_setpoint__)
|
||||
|
||||
def cancel_boost(self):
|
||||
self.set(self.KEY_BOOST_TIMER, 0, block_callback=[self.timer_expired])
|
||||
def cancel_boost(self, device=None, key=None, data=None):
|
||||
if self.boost_timer is not None:
|
||||
self.boost_timer = None
|
||||
self.gui_heating.set_timer('-')
|
||||
|
||||
def send_command(self, key, data, block_callback=[]):
|
||||
return super().set(key, data, block_callback)
|
||||
def update_states(self, away_mode=None, summer_mode=None, user_temperature_setpoint=None):
|
||||
if away_mode is not None:
|
||||
self.__away_mode__ = away_mode
|
||||
if summer_mode is not None:
|
||||
self.__summer_mode__ = summer_mode
|
||||
if user_temperature_setpoint is not None:
|
||||
self.__user_temperature_setpoint__ = user_temperature_setpoint
|
||||
set_gui_radiator_data(self.gui_heating.topic, self.__away_mode__, self.__summer_mode__, self.__user_temperature_setpoint__)
|
||||
#
|
||||
self.gui_heating.set_away(self.__away_mode__)
|
||||
self.gui_heating.set_summer(self.__summer_mode__)
|
||||
self.gui_heating.set_enable(not self.__away_mode__ and not self.__summer_mode__)
|
||||
|
||||
def away_mode(self, device, key, value):
|
||||
if value is True:
|
||||
self.cancel_boost()
|
||||
self.set(self.KEY_SUMMER_MODE, False, [self.summer_mode])
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self[self.KEY_USER_TEMPERATURE_SETPOINT] - self.AWAY_REDUCTION)
|
||||
self.update_states(away_mode=value, summer_mode=False)
|
||||
self.heating_valve.set_heating_setpoint(self.__user_temperature_setpoint__ - self.AWAY_REDUCTION)
|
||||
else:
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self[self.KEY_USER_TEMPERATURE_SETPOINT])
|
||||
self.update_states(away_mode=value)
|
||||
self.heating_valve.set_heating_setpoint(self.__user_temperature_setpoint__)
|
||||
|
||||
def summer_mode(self, device, key, value):
|
||||
if value is True:
|
||||
self.cancel_boost()
|
||||
self.set(self.KEY_AWAY_MODE, False, [self.away_mode])
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self.SUMMER_TEMPERATURE)
|
||||
self.update_states(away_mode=False, summer_mode=value)
|
||||
self.heating_valve.set_heating_setpoint(self.SUMMER_TEMPERATURE)
|
||||
else:
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self[self.KEY_USER_TEMPERATURE_SETPOINT])
|
||||
self.update_states(summer_mode=value)
|
||||
self.heating_valve.set_heating_setpoint(self.__user_temperature_setpoint__)
|
||||
|
||||
def boost(self, device, key, data):
|
||||
if self[self.KEY_BOOST_TIMER] == 0:
|
||||
if self.boost_timer is None:
|
||||
self.heating_valve.logger.info('Starting boost mode with setpoint %.1f°C.', self.BOOST_TEMPERATURE)
|
||||
self.set(self.KEY_BOOST_TIMER, 15*60)
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self.BOOST_TEMPERATURE)
|
||||
self.boost_timer = 15*60
|
||||
self.heating_valve.set_heating_setpoint(self.BOOST_TEMPERATURE)
|
||||
else:
|
||||
self.set(self.KEY_BOOST_TIMER, min(self[self.KEY_BOOST_TIMER] + 15 * 60, 60 * 60))
|
||||
self.set(self.KEY_AWAY_MODE, False, [self.away_mode])
|
||||
self.set(self.KEY_SUMMER_MODE, False, [self.summer_mode])
|
||||
self.boost_timer += 15 * 60
|
||||
if self.boost_timer > 60 * 60:
|
||||
self.boost_timer = 60 * 60
|
||||
self.update_states(away_mode=False, summer_mode=False)
|
||||
|
||||
def setpoint_to_default(self, device, key, data):
|
||||
self.cancel_boost()
|
||||
self.set(self.KEY_AWAY_MODE, False, [self.away_mode])
|
||||
self.set(self.KEY_SUMMER_MODE, False, [self.summer_mode])
|
||||
self.set(self.KEY_USER_TEMPERATURE_SETPOINT, self.default_temperature, [self.user_temperature_setpoint])
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, self.default_temperature)
|
||||
|
||||
def user_temperature_setpoint(self, device, key, data):
|
||||
self.cancel_boost()
|
||||
self.set(self.KEY_AWAY_MODE, False, [self.away_mode])
|
||||
self.set(self.KEY_SUMMER_MODE, False, [self.summer_mode])
|
||||
self.set(self.KEY_TEMPERATURE_SETPOINT, data)
|
||||
self.set_heating_setpoint(device, key, self.default_temperature)
|
||||
|
||||
def set_heating_setpoint(self, device, key, data):
|
||||
self.valve_value.new(data)
|
||||
self.cancel_boost()
|
||||
self.update_states(away_mode=False, summer_mode=False, user_temperature_setpoint=data)
|
||||
self.heating_valve.set_heating_setpoint(data)
|
||||
|
||||
def get_radiator_setpoint(self, device, key, data):
|
||||
if self.valve_value.is_valid_value(data):
|
||||
if self[self.KEY_BOOST_TIMER] == 0 and not self[self.KEY_AWAY_MODE] and not self[self.KEY_SUMMER_MODE]:
|
||||
self.set(self.KEY_USER_TEMPERATURE_SETPOINT, data, block_callback=[self.set_heating_setpoint])
|
||||
|
||||
def get_radiator_temperature(self, device, key, data):
|
||||
self.set(self.KEY_TEMPERATURE_CURRENT, data)
|
||||
|
||||
|
||||
class motion_sensor_light(common_base):
|
||||
KEY_TIMER = 'timer'
|
||||
KEY_MOTION_SENSOR = 'motion_%d'
|
||||
KEY_MOTION_SENSOR_0 = 'motion_%d' % 0
|
||||
KEY_MOTION_SENSOR_1 = 'motion_%d' % 1
|
||||
KEY_MOTION_SENSOR_2 = 'motion_%d' % 2
|
||||
KEY_MOTION_SENSOR_3 = 'motion_%d' % 3
|
||||
KEY_MOTION_SENSOR_4 = 'motion_%d' % 4
|
||||
|
||||
def __init__(self, sw_device, sw_method, *args, timer_value=30):
|
||||
"""
|
||||
sw_device is the device switching the light, args are 0-n motion sensors
|
||||
"""
|
||||
dv = dict.fromkeys([self.KEY_MOTION_SENSOR % i for i in range(0, len(args))])
|
||||
for key in dv:
|
||||
dv[key] = False
|
||||
dv[self.KEY_TIMER] = 0
|
||||
super().__init__(default_values=dv)
|
||||
#
|
||||
self.sw_device = sw_device
|
||||
self.sw_method = sw_method
|
||||
self.motion_sensors = args
|
||||
self.timer_reload_value = timer_value
|
||||
#
|
||||
sw_device.add_callback(devices.shelly_sw1.KEY_OUTPUT_0, True, self.reload_timer, True)
|
||||
sw_device.add_callback(devices.shelly_sw1.KEY_OUTPUT_0, False, self.reset_timer, True)
|
||||
for motion_sensor in args:
|
||||
motion_sensor.add_callback(motion_sensor.KEY_OCCUPANCY, None, self.set_motion_detected, True)
|
||||
#
|
||||
self.add_callback(self.KEY_TIMER, 0, self.timer_expired, True)
|
||||
#
|
||||
cyclic_task = task.periodic(1, self.cyclic_task)
|
||||
cyclic_task.run()
|
||||
|
||||
def reload_timer(self, device, key, data):
|
||||
self.set(self.KEY_TIMER, self.timer_reload_value)
|
||||
|
||||
def reset_timer(self, device=None, key=None, data=None):
|
||||
self.set(self.KEY_TIMER, 0)
|
||||
|
||||
def set_motion_detected(self, device, key, data):
|
||||
for sensor_index, arg_device in enumerate(self.motion_sensors):
|
||||
if arg_device.topic == device.topic:
|
||||
break
|
||||
self.set(self.KEY_MOTION_SENSOR % sensor_index, data)
|
||||
# auto light on with state sunset -> time_offset_sunrise=60 (longer sunset) and time_offset_sunset=-60 (longer sunset)
|
||||
if day_state(None, None, 60, -60).get_state() == day_state.KEY_SUNSET:
|
||||
if data is True:
|
||||
logger.info("%s: Motion detected - Switching on main light %s", device.topic, self.sw_device.topic)
|
||||
self.sw_method(True)
|
||||
|
||||
def motion_detected(self):
|
||||
for i in range(0, len(self.motion_sensors)):
|
||||
if self[self.KEY_MOTION_SENSOR % i]:
|
||||
return True
|
||||
return False
|
||||
|
||||
def timer_expired(self, device, key, data):
|
||||
logger.info("No motion and time ran out - Switching off main light %s", self.sw_device.topic)
|
||||
self.sw_method(False)
|
||||
|
||||
def cyclic_task(self, cyclic_task):
|
||||
min_value = 10 if self.motion_detected() else 0
|
||||
if self[self.KEY_TIMER] != 0:
|
||||
self.set(self.KEY_TIMER, max(min_value, self[self.KEY_TIMER] - cyclic_task.cycle_time))
|
||||
if self.boost_timer is None and not self.__away_mode__ and not self.__summer_mode__:
|
||||
self.update_states(user_temperature_setpoint=data)
|
||||
else:
|
||||
self.update_states()
|
||||
self.gui_heating.set_setpoint_temperature(data)
|
||||
|
||||
@ -2,8 +2,11 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
#
|
||||
|
||||
import config
|
||||
import devices
|
||||
from function.helpers import now, sunset_time, sunrise_time
|
||||
import logging
|
||||
import inspect
|
||||
import task
|
||||
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
@ -13,67 +16,134 @@ logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class room(object):
|
||||
ADD_TO_VIDEV_ALL_OFF = None
|
||||
|
||||
def __init__(self, mqtt_client):
|
||||
self.mqtt_client = mqtt_client
|
||||
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching all off \"%s\"", type(self).__name__)
|
||||
for name, obj in inspect.getmembers(self):
|
||||
try:
|
||||
if obj.__module__.startswith('smart_devices'):
|
||||
obj.all_off()
|
||||
except AttributeError:
|
||||
pass # not a module or has no method all_off
|
||||
|
||||
def summer_mode(self, enable):
|
||||
for name, obj in inspect.getmembers(self):
|
||||
if obj.__class__.__name__ == 'heating_function':
|
||||
if obj.__module__ == 'function.modules':
|
||||
obj.set(obj.KEY_SUMMER_MODE, enable)
|
||||
|
||||
|
||||
class room_collection(object):
|
||||
ADD_TO_VIDEV_ALL_OFF = None
|
||||
|
||||
def __init__(self, mqtt_client):
|
||||
self.mqtt_client = mqtt_client
|
||||
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
logger.info("Switching all off \"%s\"", type(self).__name__)
|
||||
for sub_name in dir(self):
|
||||
# attribute name is not private
|
||||
if not sub_name.startswith("__"):
|
||||
sub = getattr(self, sub_name)
|
||||
# try to call all_off
|
||||
try:
|
||||
sub.all_off()
|
||||
except AttributeError:
|
||||
pass # don't mind, if sub has no method all_off
|
||||
except:
|
||||
logger.error("Failed to switch off %s (%s)", repr(sub_name), type(sub).__name__)
|
||||
|
||||
def summer_mode(self, device=None, key=None, data=None):
|
||||
logger.info("Changing to %s \"%s\"", "summer mode" if data else "winter_mode", type(self).__name__)
|
||||
for sub_name in dir(self):
|
||||
# attribute name is not private
|
||||
if not sub_name.startswith("__"):
|
||||
sub = getattr(self, sub_name)
|
||||
if isinstance(sub, (room, room_collection)):
|
||||
sub.summer_mode(data)
|
||||
|
||||
def all_devices(self, object_to_analyse=None, depth=0):
|
||||
target = object_to_analyse or self
|
||||
class room_shelly(room):
|
||||
def __init__(self, mqtt_client, topic_shelly, topic_gui):
|
||||
super().__init__(mqtt_client)
|
||||
self.main_light_shelly = devices.shelly(mqtt_client, topic_shelly)
|
||||
#
|
||||
devices = []
|
||||
for name, obj in inspect.getmembers(target):
|
||||
if not callable(obj): # sort out methods
|
||||
try:
|
||||
if obj.__module__.startswith('function.') and not obj.__module__.endswith('.videv'):
|
||||
devices.extend(self.all_devices(obj, depth+1)) # rekurse in function instances
|
||||
elif obj.__module__ == "devices":
|
||||
devices.append(obj)
|
||||
except AttributeError:
|
||||
pass # sort out non modules
|
||||
return devices
|
||||
self.gui_main_light = devices.nodered_gui_light(mqtt_client, topic_gui)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.gui_main_light.add_callback(devices.nodered_gui_light.KEY_STATE, None, self.main_light_shelly.set_output_0_mcb)
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.gui_main_light.set_state_mcb)
|
||||
#
|
||||
self.block_all_off = False
|
||||
self.last_flash_data = None
|
||||
self.delayed_task = task.delayed(.25, self.main_light_shelly.toggle_output_0_mcb, None, None, None)
|
||||
|
||||
def all_off(self, device=None, key=None, data=None):
|
||||
if not self.block_all_off:
|
||||
logger.info("Switching all off \"%s\"", type(self).__name__)
|
||||
self.main_light_shelly.set_output_0(False)
|
||||
self.main_light_shelly.set_output_1(False)
|
||||
self.block_all_off = False
|
||||
|
||||
def all_off_feedback(self, device=None, key=None, data=None):
|
||||
logger.info("Flashing \"%s\" main light", type(self).__name__)
|
||||
if self.main_light_shelly.output_0 is False:
|
||||
self.main_light_shelly.set_output_0(True)
|
||||
self.block_all_off = True
|
||||
self.delayed_task.run()
|
||||
|
||||
def flash_main_light(self, device, key, data):
|
||||
if self.last_flash_data != data and data is True:
|
||||
logger.info("Flashing \"%s\" main light", type(self).__name__)
|
||||
self.main_light_shelly.toggle_output_0_mcb(device, key, data)
|
||||
self.delayed_task.run()
|
||||
self.last_flash_data = data
|
||||
|
||||
|
||||
class room_shelly_motion_sensor(room_shelly):
|
||||
def __init__(self, mqtt_client, topic_shelly, topic_gui, topic_motion_sensor_1, topic_motion_sensor_2=None, timer_value=30):
|
||||
super().__init__(mqtt_client, topic_shelly, topic_gui)
|
||||
self.timer_value = timer_value
|
||||
self.motion_detected_1 = False
|
||||
self.motion_detected_2 = False
|
||||
#
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, True, self.reload_timer, True)
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, False, self.reset_timer, True)
|
||||
#
|
||||
self.motion_sensor_silvercrest_1 = devices.silvercrest_motion_sensor(mqtt_client, topic_motion_sensor_1)
|
||||
self.motion_sensor_silvercrest_1.add_callback(devices.silvercrest_motion_sensor.KEY_OCCUPANCY, None, self.set_motion_detected)
|
||||
#
|
||||
if topic_motion_sensor_2 is not None:
|
||||
self.motion_sensor_silvercrest_2 = devices.silvercrest_motion_sensor(mqtt_client, topic_motion_sensor_2)
|
||||
self.motion_sensor_silvercrest_2.add_callback(devices.silvercrest_motion_sensor.KEY_OCCUPANCY, None, self.set_motion_detected)
|
||||
#
|
||||
self.reset_timer()
|
||||
#
|
||||
cyclic_task = task.periodic(1, self.cyclic_task)
|
||||
cyclic_task.run()
|
||||
|
||||
def set_motion_detected(self, device, key, data):
|
||||
if device == self.motion_sensor_silvercrest_1:
|
||||
self.motion_detected_1 = data
|
||||
elif device == self.motion_sensor_silvercrest_2:
|
||||
self.motion_detected_2 = data
|
||||
self.gui_main_light.set_led(devices.nodered_gui_light.KEY_LED_0, self.motion_detected_1)
|
||||
self.gui_main_light.set_led(devices.nodered_gui_light.KEY_LED_1, self.motion_detected_2)
|
||||
if now() < sunrise_time(60) or now() > sunset_time(-60):
|
||||
if data is True:
|
||||
logger.info("%s: Motion detected - Switching on main light %s", device.topic, self.main_light_shelly.topic)
|
||||
self.main_light_shelly.set_output_0(True)
|
||||
|
||||
def reload_timer(self, device, key, data):
|
||||
self.main_light_timer = self.timer_value
|
||||
|
||||
def reset_timer(self, device=None, key=None, data=None):
|
||||
self.main_light_timer = None
|
||||
self.motion_detected_1 = False
|
||||
self.motion_detected_2 = False
|
||||
|
||||
def cyclic_task(self, cyclic_task):
|
||||
if self.main_light_timer is not None:
|
||||
if self.main_light_timer <= 0:
|
||||
logger.info("No motion and time ran out - Switching off main light %s", self.main_light_shelly.topic)
|
||||
self.main_light_shelly.set_output_0(False)
|
||||
self.main_light_timer = None
|
||||
self.gui_main_light.set_timer('-')
|
||||
else:
|
||||
self.gui_main_light.set_timer(self.main_light_timer)
|
||||
if (self.motion_detected_1 or self.motion_detected_2) and self.main_light_timer <= self.timer_value / 10:
|
||||
self.main_light_timer = self.timer_value / 10
|
||||
else:
|
||||
self.main_light_timer -= cyclic_task.cycle_time
|
||||
|
||||
|
||||
class room_shelly_tradfri_light(room_shelly):
|
||||
def __init__(self, mqtt_client, topic_shelly, topic_gui, topic_tradfri_light):
|
||||
super().__init__(mqtt_client, topic_shelly, topic_gui)
|
||||
self.main_light_tradfri = devices.tradfri_light(mqtt_client, topic_tradfri_light)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.gui_main_light.set_state_mcb)
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.gui_main_light.set_enable_mcb)
|
||||
self.main_light_tradfri.add_callback(devices.tradfri_light.KEY_BRIGHTNESS, None, self.gui_main_light.set_brightness_mcb)
|
||||
self.main_light_tradfri.add_callback(devices.tradfri_light.KEY_COLOR_TEMP, None, self.gui_main_light.set_color_temp_mcb)
|
||||
self.gui_main_light.add_callback(devices.nodered_gui_light.KEY_BRIGHTNESS, None, self.main_light_tradfri.set_brightness_mcb)
|
||||
self.gui_main_light.add_callback(devices.nodered_gui_light.KEY_COLOR_TEMP, None, self.main_light_tradfri.set_color_temp_mcb)
|
||||
|
||||
|
||||
class room_shelly_silvercrest_light(room_shelly_tradfri_light):
|
||||
def __init__(self, mqtt_client, topic_shelly, topic_gui, topic_tradfri_light):
|
||||
super().__init__(mqtt_client, topic_shelly, topic_gui, topic_tradfri_light)
|
||||
#
|
||||
# Callback initialisation
|
||||
#
|
||||
self.main_light_shelly.add_callback(devices.shelly.KEY_OUTPUT_0, None, self.get_initial_main_light_data)
|
||||
#
|
||||
self.main_light_shelly_last = None
|
||||
|
||||
def get_initial_main_light_data(self, device, key, data):
|
||||
if data is True and self.main_light_shelly_last != data:
|
||||
self.send_init_message_main_light()
|
||||
self.main_light_shelly_last = data
|
||||
|
||||
def send_init_message_main_light(self):
|
||||
self.main_light_tradfri.mqtt_client.send(self.main_light_tradfri.topic + "/get", '{"state": ""}')
|
||||
|
||||
@ -3,11 +3,9 @@
|
||||
#
|
||||
|
||||
import config
|
||||
from devdi import rooms
|
||||
from function.modules import brightness_choose_n_action
|
||||
import logging
|
||||
from function.modules import motion_sensor_light
|
||||
from function.rooms import room, room_collection
|
||||
|
||||
from function.rooms import room_shelly_motion_sensor
|
||||
try:
|
||||
from config import APP_NAME as ROOT_LOGGER_NAME
|
||||
except ImportError:
|
||||
@ -15,23 +13,9 @@ except ImportError:
|
||||
logger = logging.getLogger(ROOT_LOGGER_NAME).getChild(__name__)
|
||||
|
||||
|
||||
class stairway(room_collection):
|
||||
class stairway(room_shelly_motion_sensor):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
self.stairway = stairway_stairway(mqtt_client)
|
||||
|
||||
|
||||
class stairway_stairway(rooms.stairway, room):
|
||||
def __init__(self, mqtt_client):
|
||||
super().__init__(mqtt_client)
|
||||
room.__init__(self, mqtt_client)
|
||||
#
|
||||
# connect videv and switch
|
||||
self.videv_main_light.connect_sw_device(self.switch_main_light, self.switch_main_light.KEY_OUTPUT_0)
|
||||
|
||||
self.motion_sensor_light = motion_sensor_light(
|
||||
self.switch_main_light, self.switch_main_light.set_output_0,
|
||||
self.motion_main_light_gf, self.motion_main_light_ff,
|
||||
timer_value=config.USER_ON_TIME_STAIRWAYS
|
||||
)
|
||||
self.videv_main_light.connect_mo_function(self.motion_sensor_light)
|
||||
# http://shelly1-3494546A9364
|
||||
super().__init__(mqtt_client, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_SHELLY, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_GUI,
|
||||
config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_MOTION_SENSOR_GF, config.TOPIC_STW_STAIRWAY_MAIN_LIGHT_MOTION_SENSOR_FF,
|
||||
timer_value=config.USER_ON_TIME_STAIRWAYS)
|
||||
|
||||
2
geo
2
geo
@ -1 +1 @@
|
||||
Subproject commit edc3c9975ec723abf81e9ba52b4012f4674f3ac5
|
||||
Subproject commit 11166bb27ad2335f7812fcb88c788397f5106751
|
||||
80
house_n_gui_sim.py
Normal file
80
house_n_gui_sim.py
Normal file
@ -0,0 +1,80 @@
|
||||
import config
|
||||
import logging
|
||||
import mqtt
|
||||
import readline
|
||||
import report
|
||||
from __simulation__.rooms import house
|
||||
from __simulation__.test import test_smarthome
|
||||
import time
|
||||
|
||||
if __name__ == "__main__":
|
||||
report.stdoutLoggingConfigure(((config.APP_NAME, logging.WARNING), ), report.SHORT_FMT)
|
||||
#
|
||||
mc = mqtt.mqtt_client(host=config.MQTT_SERVER, port=config.MQTT_PORT, username=config.MQTT_USER,
|
||||
password=config.MQTT_PASSWORD, name=config.APP_NAME + '_simulation')
|
||||
#
|
||||
COMMANDS = ['quit', 'help', 'test.smoke', 'test.full']
|
||||
#
|
||||
h = house(mc)
|
||||
for name in h.getmembers():
|
||||
d = h.getobjbyname(name)
|
||||
for c in d.capabilities():
|
||||
COMMANDS.append(name + '.' + c)
|
||||
#
|
||||
ts = test_smarthome(h)
|
||||
|
||||
def reduced_list(text):
|
||||
"""
|
||||
Create reduced completation list
|
||||
"""
|
||||
reduced_list = {}
|
||||
for cmd in COMMANDS:
|
||||
next_dot = cmd[len(text):].find('.')
|
||||
if next_dot >= 0:
|
||||
reduced_list[cmd[:len(text) + next_dot + 1]] = None
|
||||
else:
|
||||
reduced_list[cmd] = None
|
||||
return reduced_list.keys()
|
||||
|
||||
def completer(text, state):
|
||||
"""
|
||||
Our custom completer function
|
||||
"""
|
||||
options = [x for x in reduced_list(text) if x.startswith(text)]
|
||||
return options[state]
|
||||
|
||||
def complete(text, state):
|
||||
for cmd in COMMANDS:
|
||||
if cmd.startswith(text):
|
||||
if not state:
|
||||
hit = ""
|
||||
index = 0
|
||||
sub_list = cmd.split('.')
|
||||
while len(text) >= len(hit):
|
||||
hit += sub_list[index] + '.'
|
||||
return hit # cmd
|
||||
else:
|
||||
state -= 1
|
||||
|
||||
readline.parse_and_bind("tab: complete")
|
||||
readline.set_completer(completer)
|
||||
time.sleep(0.3)
|
||||
print("\nEnter command: ")
|
||||
|
||||
while True:
|
||||
userfeedback = input('')
|
||||
command = userfeedback.split(' ')[0]
|
||||
if userfeedback == 'quit':
|
||||
break
|
||||
elif userfeedback == 'help':
|
||||
print("Help is not yet implemented!")
|
||||
elif userfeedback == 'test.full':
|
||||
ts.full()
|
||||
elif userfeedback == 'test.smoke':
|
||||
ts.smoke()
|
||||
elif command in COMMANDS[2:]:
|
||||
h.command(userfeedback)
|
||||
elif userfeedback != "":
|
||||
print("Unknown command!")
|
||||
else:
|
||||
print()
|
||||
2
mqtt
2
mqtt
@ -1 +1 @@
|
||||
Subproject commit c2b32852127bc1a3aca078a2dad3993f46cb81c2
|
||||
Subproject commit 1adfb0626e7777c6d29be65d4ad4ce2d57541301
|
||||
2
report
2
report
@ -1 +1 @@
|
||||
Subproject commit 152690007a3b87ee0047bcad78b2673111ff1928
|
||||
Subproject commit e2392c9f28d88ee54463681850acf95ae496c9a0
|
||||
@ -1,53 +1,26 @@
|
||||
import config
|
||||
import function
|
||||
import json
|
||||
import logging
|
||||
import mqtt
|
||||
import os
|
||||
import report
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
logger = report.default_logging_config()
|
||||
|
||||
|
||||
VERS_MAJOR = 1
|
||||
VERS_MINOR = 4
|
||||
VERS_PATCH = 3
|
||||
|
||||
INFO_TOPIC = "__info__"
|
||||
INFO_DATA = {
|
||||
"app_name": os.path.splitext(os.path.basename(__file__))[0],
|
||||
"version": {
|
||||
"readable": "%d.%d.%d" % (VERS_MAJOR, VERS_MINOR, VERS_PATCH),
|
||||
"major": VERS_MAJOR,
|
||||
"minor": VERS_MINOR,
|
||||
"patch": VERS_PATCH
|
||||
},
|
||||
"git": {
|
||||
"url": subprocess.check_output(["git", "config", "--get", "remote.origin.url"])[:-1].decode("utf-8"),
|
||||
"ref": subprocess.check_output(["git", "log", "-1", '--format="%H"'])[1:-2].decode("utf-8")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def __info_publisher__(client, userdata, message):
|
||||
data = json.loads(message.payload)
|
||||
if data != INFO_DATA:
|
||||
client.publish(INFO_TOPIC, json.dumps(INFO_DATA))
|
||||
logger = logging.getLogger(config.APP_NAME)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
#
|
||||
# MQTT Client
|
||||
if config.DEBUG:
|
||||
report.appLoggingConfigure(None, None, ((config.APP_NAME, logging.DEBUG), ), fmt=report.SHORT_FMT, host='localhost', port=19996)
|
||||
else:
|
||||
report.stdoutLoggingConfigure(((config.APP_NAME, logging.INFO), ), report.SHORT_FMT)
|
||||
#
|
||||
mc = mqtt.mqtt_client(host=config.MQTT_SERVER, port=config.MQTT_PORT, username=config.MQTT_USER,
|
||||
password=config.MQTT_PASSWORD, name=config.APP_NAME)
|
||||
mc.add_callback(INFO_TOPIC, __info_publisher__)
|
||||
|
||||
#
|
||||
# Smart Home Functionality
|
||||
#
|
||||
func = function.all_functions(mc)
|
||||
|
||||
while (func.run):
|
||||
# for device in func.devicelist():
|
||||
# device.add_warning_callback(None)
|
||||
|
||||
while (True):
|
||||
time.sleep(1)
|
||||
|
||||
@ -1 +0,0 @@
|
||||
Subproject commit c75c0cfacd48e9d51817f128539f96487cef2f98
|
||||
2
task
2
task
@ -1 +1 @@
|
||||
Subproject commit bb6f7ea26f24481cba7218256e47572fa84db478
|
||||
Subproject commit af35e83d1f07fd4cb9070bdb77cf1f3bdda3a463
|
||||
Caricamento…
x
Fai riferimento in un nuovo problema
Block a user